yuzu/mbedtls
1
0
Fork 0
mirror of https://github.com/yuzu-emu/mbedtls.git synced 2024-12-26 07:35:35 +00:00
Code Issues Packages Projects Releases Wiki Activity
mbedtls/library/x509_crt.c

3670 lines
111 KiB
C
Raw Normal View History

- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
/*
Update description and references for X.509 files
2014-06-12 20:34:55 +00:00
* X.509 certificate parsing and verification
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*
Update date in copyright line
2015-07-27 09:11:48 +00:00
* Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
Change main license to Apache 2.0
2015-09-04 12:21:07 +00:00
* SPDX-License-Identifier: Apache-2.0
- Fixed copyright message
2010-07-18 20:36:00 +00:00
*
Change main license to Apache 2.0
2015-09-04 12:21:07 +00:00
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
- Fixed copyright message
2010-07-18 20:36:00 +00:00
*
Change main license to Apache 2.0
2015-09-04 12:21:07 +00:00
* http://www.apache.org/licenses/LICENSE-2.0
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*
Change main license to Apache 2.0
2015-09-04 12:21:07 +00:00
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*
Change main license to Apache 2.0
2015-09-04 12:21:07 +00:00
* This file is part of mbed TLS (https://tls.mbed.org)
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*/
/*
- Updated RFC ref
2012-02-16 15:28:14 +00:00
* The ITU-T X.509 standard defines a certificate format for PKI.
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*
Update description and references for X.509 files
2014-06-12 20:34:55 +00:00
* http://www.ietf.org/rfc/rfc5280.txt (Certificates and CRLs)
* http://www.ietf.org/rfc/rfc3279.txt (Alg IDs for CRLs)
* http://www.ietf.org/rfc/rfc2986.txt (CSRs, aka PKCS#10)
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*
* http://www.itu.int/ITU-T/studygroups/com17/languages/X.680-0207.pdf
* http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf
Add badkey-skipping to find_parent() This is the last step towards removing the now-duplicated parent-searching code in verify_top()
2017-07-03 16:30:43 +00:00
*
* [SIRO] https://cabforum.org/wp-content/uploads/Chunghwatelecom201503cabforumV4.pdf
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*/
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if !defined(MBEDTLS_CONFIG_FILE)
Rename include directory to mbedtls
2015-03-09 17:05:11 +00:00
#include "mbedtls/config.h"
Adapt sources to configurable config.h name
2014-04-29 10:39:06 +00:00
#else
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#include MBEDTLS_CONFIG_FILE
Adapt sources to configurable config.h name
2014-04-29 10:39:06 +00:00
#endif
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_X509_CRT_PARSE_C)
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Rename include directory to mbedtls
2015-03-09 17:05:11 +00:00
#include "mbedtls/x509_crt.h"
Move declarations of internal X.509 functions to separate header This makes it easier to distinguish public from internal functions; for us, for users, and for automated API compatibility checkers.
2019-05-02 12:05:58 +00:00
#include "mbedtls/x509_internal.h"
Rename include directory to mbedtls
2015-03-09 17:05:11 +00:00
#include "mbedtls/oid.h"
Rename mbedtls_zeroize to mbedtls_platform_zeroize
2018-04-17 14:51:09 +00:00
#include "mbedtls/platform_util.h"
cleanup library and some basic tests. Includes, add guards to includes
2015-02-06 13:43:58 +00:00
#include <string.h>
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_PEM_PARSE_C)
Rename include directory to mbedtls
2015-03-09 17:05:11 +00:00
#include "mbedtls/pem.h"
POLARSSL_PEM_C split into POLARSSL_PEM_PARSE_C and POLARSSL_PEM_WRITE_C
2013-09-15 18:43:33 +00:00
#endif
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_PLATFORM_C)
Rename include directory to mbedtls
2015-03-09 17:05:11 +00:00
#include "mbedtls/platform.h"
Memory-allocation abstraction layer and buffer-based allocator added
2013-07-03 11:37:05 +00:00
#else
Make inclusion of stdio.h conditional in x509_crt.c stdio.h was being included both conditionally if MBEDTLS_FS_IO was defined, and also unconditionally, which made at least one of them redundant. This change removes the unconditional inclusion of stdio.h and makes it conditional on MBEDTLS_PLATFORM_C.
2018-10-03 14:11:19 +00:00
#include <stdio.h>
cleanup library and some basic tests. Includes, add guards to includes
2015-02-06 13:43:58 +00:00
#include <stdlib.h>
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#define mbedtls_free free
Replace malloc with calloc - platform layer currently broken (not adapted yet) - memmory_buffer_alloc too
2015-05-26 14:04:06 +00:00
#define mbedtls_calloc calloc
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#define mbedtls_snprintf snprintf
Memory-allocation abstraction layer and buffer-based allocator added
2013-07-03 11:37:05 +00:00
#endif
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_THREADING_C)
Rename include directory to mbedtls
2015-03-09 17:05:11 +00:00
#include "mbedtls/threading.h"
Mutex x509_crt_parse_path() when pthreads is used
2013-11-28 16:11:54 +00:00
#endif
Defines for UEFI environment under MSVC added
2013-10-28 17:48:30 +00:00
#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
- Lots of minimal changes to better support WINCE as a build target
2011-11-18 14:26:47 +00:00
#include <windows.h>
#else
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
#include <time.h>
- Lots of minimal changes to better support WINCE as a build target
2011-11-18 14:26:47 +00:00
#endif
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_FS_IO)
cleanup library and some basic tests. Includes, add guards to includes
2015-02-06 13:43:58 +00:00
#include <stdio.h>
Small fix for EFI build under Windows in x509_crt.c
2014-04-04 13:08:20 +00:00
#if !defined(_WIN32) || defined(EFIX64) || defined(EFI32)
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
#include <sys/types.h>
x509parse_crtpath() is now reentrant and uses more portable stat() Moved from readdir() to readdir_r() and use stat instead of the less portable d_type from struct dirent. (cherry picked from commit cbfcaa9206be586f6bf8ac26586cd63a6c8c8e15)
2013-06-24 17:22:42 +00:00
#include <sys/stat.h>
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
#include <dirent.h>
cleanup library and some basic tests. Includes, add guards to includes
2015-02-06 13:43:58 +00:00
#endif /* !_WIN32 || EFIX64 || EFI32 */
- Functions requiring File System functions can now be disables by undefining POLARSSL_FS_IO
2011-04-25 15:28:35 +00:00
#endif
Introduce helpers for conversion between X.509 buffer structs This commit introduces two static helpers - `x509_buf_to_buf_raw()` - `x509_buf_raw_to_buf()` which convert to/from the old `mbedtls_x509_buf` and the new `mbedtls_x509_buf_raw` (the latter omitting the ASN.1 tag field).
2019-03-04 15:13:45 +00:00
#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
static void x509_buf_to_buf_raw( mbedtls_x509_buf_raw *dst,
mbedtls_x509_buf const *src )
{
dst->p = src->p;
dst->len = src->len;
}
static void x509_buf_raw_to_buf( mbedtls_x509_buf *dst,
mbedtls_x509_buf_raw const *src )
{
dst->p = src->p;
dst->len = src->len;
}
#endif /* MBEDTLS_X509_ON_DEMAND_PARSING */
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
static int x509_crt_parse_frame( unsigned char *start,
unsigned char *end,
mbedtls_x509_crt_frame *frame );
Mark CRT frame argument to mbedtls_x509_xxx_from_frame() constant
2019-05-13 12:53:21 +00:00
static int x509_crt_subject_from_frame( mbedtls_x509_crt_frame const *frame,
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
mbedtls_x509_name *subject );
Mark CRT frame argument to mbedtls_x509_xxx_from_frame() constant
2019-05-13 12:53:21 +00:00
static int x509_crt_issuer_from_frame( mbedtls_x509_crt_frame const *frame,
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
mbedtls_x509_name *issuer );
Mark CRT frame argument to mbedtls_x509_xxx_from_frame() constant
2019-05-13 12:53:21 +00:00
static int x509_crt_subject_alt_from_frame( mbedtls_x509_crt_frame const *frame,
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
mbedtls_x509_sequence *subject_alt );
Mark CRT frame argument to mbedtls_x509_xxx_from_frame() constant
2019-05-13 12:53:21 +00:00
static int x509_crt_ext_key_usage_from_frame( mbedtls_x509_crt_frame const *frame,
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
mbedtls_x509_sequence *ext_key_usage );
Implement MBEDTLS_X509_ALWAYS_FLUSH
2019-03-05 15:35:31 +00:00
int mbedtls_x509_crt_flush_cache_pk( mbedtls_x509_crt const *crt )
{
#if defined(MBEDTLS_THREADING_C)
if( mbedtls_mutex_lock( &crt->cache->pk_mutex ) != 0 )
return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
Make X.509 CRT cache reference counting unconditional Previously, reference counting for the CRT frames and PK contexts handed out by mbedtls_x509_crt_{frame|pk}_acquire() was implemented only in case threading support was enabled, which leaves the door open for a potential use-after-free should a single-threaded application use nested calls to mbedtls_x509_crt_acquire(). Since Mbed TLS itself does not use such nested calls, it might be preferred long-term to forbid nesting of acquire calls on the API level, and hence get rid of reference counting in the interest of code-size benefits. However, this can be considered as an optimization of X.509 on demand parsing, and for now this commit introduces reference counting unconditionally to have a safe version of on demand parsing to build further optimizations upon.
2019-06-28 09:34:23 +00:00
#endif
Don't allow nested CRT acquire()-calls if MBEDTLS_X509_ALWAYS_FLUSH Forbidding nested calls to acquire() allows to remove the reference counting logic and hence saving some bytes of code. This is valuable because MBEDTLS_X509_ALWAYS_FLUSH is likely to be used on constrained systems where code-size is limited.
2019-06-28 13:45:26 +00:00
#if !defined(MBEDTLS_X509_ALWAYS_FLUSH) || \
defined(MBEDTLS_THREADING_C)
/* Can only free the PK context if nobody is using it.
* If MBEDTLS_X509_ALWAYS_FLUSH is set, nested uses
* of xxx_acquire() are prohibited, and no reference
* counting is needed. Also, notice that the code-path
* below is safe if the cache isn't filled. */
Allow multiple concurrent readers for X.509 CRT frame and PK context Previously, only one thread could access the parsing cache of an X.509 CRT at a time. Firstly, this leads to significant performance penalties on systems running many concurrent threads which share CRT structures -- for example, server threads sharing an SSL configuration containing the server CRT. Secondly, the locking should be logically unnecessary, because the threads are supposed to access the CRT frame and PK in a read-only, or at least thread-safe manner. This commit modifies the X.509 CRT cache implementation by allowing an arbitrary number of concurrent readers, locking only the path of setting up and clearing the cache.
2019-05-28 15:11:43 +00:00
if( crt->cache->pk_readers == 0 )
Don't allow nested CRT acquire()-calls if MBEDTLS_X509_ALWAYS_FLUSH Forbidding nested calls to acquire() allows to remove the reference counting logic and hence saving some bytes of code. This is valuable because MBEDTLS_X509_ALWAYS_FLUSH is likely to be used on constrained systems where code-size is limited.
2019-06-28 13:45:26 +00:00
#endif /* !MBEDTLS_X509_ALWAYS_FLUSH ||
MBEDTLS_THREADING_C */
Allow multiple concurrent readers for X.509 CRT frame and PK context Previously, only one thread could access the parsing cache of an X.509 CRT at a time. Firstly, this leads to significant performance penalties on systems running many concurrent threads which share CRT structures -- for example, server threads sharing an SSL configuration containing the server CRT. Secondly, the locking should be logically unnecessary, because the threads are supposed to access the CRT frame and PK in a read-only, or at least thread-safe manner. This commit modifies the X.509 CRT cache implementation by allowing an arbitrary number of concurrent readers, locking only the path of setting up and clearing the cache.
2019-05-28 15:11:43 +00:00
{
Implement MBEDTLS_X509_ALWAYS_FLUSH
2019-03-05 15:35:31 +00:00
#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
Allow multiple concurrent readers for X.509 CRT frame and PK context Previously, only one thread could access the parsing cache of an X.509 CRT at a time. Firstly, this leads to significant performance penalties on systems running many concurrent threads which share CRT structures -- for example, server threads sharing an SSL configuration containing the server CRT. Secondly, the locking should be logically unnecessary, because the threads are supposed to access the CRT frame and PK in a read-only, or at least thread-safe manner. This commit modifies the X.509 CRT cache implementation by allowing an arbitrary number of concurrent readers, locking only the path of setting up and clearing the cache.
2019-05-28 15:11:43 +00:00
/* The cache holds a shallow copy of the PK context
* in the legacy struct, so don't free PK context. */
mbedtls_free( crt->cache->pk );
Implement MBEDTLS_X509_ALWAYS_FLUSH
2019-03-05 15:35:31 +00:00
#else
Allow multiple concurrent readers for X.509 CRT frame and PK context Previously, only one thread could access the parsing cache of an X.509 CRT at a time. Firstly, this leads to significant performance penalties on systems running many concurrent threads which share CRT structures -- for example, server threads sharing an SSL configuration containing the server CRT. Secondly, the locking should be logically unnecessary, because the threads are supposed to access the CRT frame and PK in a read-only, or at least thread-safe manner. This commit modifies the X.509 CRT cache implementation by allowing an arbitrary number of concurrent readers, locking only the path of setting up and clearing the cache.
2019-05-28 15:11:43 +00:00
mbedtls_pk_free( crt->cache->pk );
mbedtls_free( crt->cache->pk );
Implement MBEDTLS_X509_ALWAYS_FLUSH
2019-03-05 15:35:31 +00:00
#endif /* MBEDTLS_X509_ON_DEMAND_PARSING */
Allow multiple concurrent readers for X.509 CRT frame and PK context Previously, only one thread could access the parsing cache of an X.509 CRT at a time. Firstly, this leads to significant performance penalties on systems running many concurrent threads which share CRT structures -- for example, server threads sharing an SSL configuration containing the server CRT. Secondly, the locking should be logically unnecessary, because the threads are supposed to access the CRT frame and PK in a read-only, or at least thread-safe manner. This commit modifies the X.509 CRT cache implementation by allowing an arbitrary number of concurrent readers, locking only the path of setting up and clearing the cache.
2019-05-28 15:11:43 +00:00
crt->cache->pk = NULL;
}
Implement MBEDTLS_X509_ALWAYS_FLUSH
2019-03-05 15:35:31 +00:00
#if defined(MBEDTLS_THREADING_C)
if( mbedtls_mutex_unlock( &crt->cache->pk_mutex ) != 0 )
return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
#endif
return( 0 );
}
int mbedtls_x509_crt_flush_cache_frame( mbedtls_x509_crt const *crt )
{
#if defined(MBEDTLS_THREADING_C)
if( mbedtls_mutex_lock( &crt->cache->frame_mutex ) != 0 )
return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
Make X.509 CRT cache reference counting unconditional Previously, reference counting for the CRT frames and PK contexts handed out by mbedtls_x509_crt_{frame|pk}_acquire() was implemented only in case threading support was enabled, which leaves the door open for a potential use-after-free should a single-threaded application use nested calls to mbedtls_x509_crt_acquire(). Since Mbed TLS itself does not use such nested calls, it might be preferred long-term to forbid nesting of acquire calls on the API level, and hence get rid of reference counting in the interest of code-size benefits. However, this can be considered as an optimization of X.509 on demand parsing, and for now this commit introduces reference counting unconditionally to have a safe version of on demand parsing to build further optimizations upon.
2019-06-28 09:34:23 +00:00
#endif
Implement MBEDTLS_X509_ALWAYS_FLUSH
2019-03-05 15:35:31 +00:00
Don't allow nested CRT acquire()-calls if MBEDTLS_X509_ALWAYS_FLUSH Forbidding nested calls to acquire() allows to remove the reference counting logic and hence saving some bytes of code. This is valuable because MBEDTLS_X509_ALWAYS_FLUSH is likely to be used on constrained systems where code-size is limited.
2019-06-28 13:45:26 +00:00
#if !defined(MBEDTLS_X509_ALWAYS_FLUSH) || \
defined(MBEDTLS_THREADING_C)
/* Can only free the PK context if nobody is using it.
* If MBEDTLS_X509_ALWAYS_FLUSH is set, nested uses
* of xxx_acquire() are prohibited, and no reference
* counting is needed. Also, notice that the code-path
* below is safe if the cache isn't filled. */
Allow multiple concurrent readers for X.509 CRT frame and PK context Previously, only one thread could access the parsing cache of an X.509 CRT at a time. Firstly, this leads to significant performance penalties on systems running many concurrent threads which share CRT structures -- for example, server threads sharing an SSL configuration containing the server CRT. Secondly, the locking should be logically unnecessary, because the threads are supposed to access the CRT frame and PK in a read-only, or at least thread-safe manner. This commit modifies the X.509 CRT cache implementation by allowing an arbitrary number of concurrent readers, locking only the path of setting up and clearing the cache.
2019-05-28 15:11:43 +00:00
if( crt->cache->frame_readers == 0 )
Don't allow nested CRT acquire()-calls if MBEDTLS_X509_ALWAYS_FLUSH Forbidding nested calls to acquire() allows to remove the reference counting logic and hence saving some bytes of code. This is valuable because MBEDTLS_X509_ALWAYS_FLUSH is likely to be used on constrained systems where code-size is limited.
2019-06-28 13:45:26 +00:00
#endif /* !MBEDTLS_X509_ALWAYS_FLUSH ||
MBEDTLS_THREADING_C */
Allow multiple concurrent readers for X.509 CRT frame and PK context Previously, only one thread could access the parsing cache of an X.509 CRT at a time. Firstly, this leads to significant performance penalties on systems running many concurrent threads which share CRT structures -- for example, server threads sharing an SSL configuration containing the server CRT. Secondly, the locking should be logically unnecessary, because the threads are supposed to access the CRT frame and PK in a read-only, or at least thread-safe manner. This commit modifies the X.509 CRT cache implementation by allowing an arbitrary number of concurrent readers, locking only the path of setting up and clearing the cache.
2019-05-28 15:11:43 +00:00
{
mbedtls_free( crt->cache->frame );
crt->cache->frame = NULL;
}
Implement MBEDTLS_X509_ALWAYS_FLUSH
2019-03-05 15:35:31 +00:00
#if defined(MBEDTLS_THREADING_C)
if( mbedtls_mutex_unlock( &crt->cache->frame_mutex ) != 0 )
return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
#endif
return( 0 );
}
int mbedtls_x509_crt_flush_cache( mbedtls_x509_crt const *crt )
{
int ret;
ret = mbedtls_x509_crt_flush_cache_frame( crt );
if( ret != 0 )
return( ret );
ret = mbedtls_x509_crt_flush_cache_pk( crt );
if( ret != 0 )
return( ret );
return( 0 );
}
Provide direct way of setting up a CRT frame from legacy CRT struct Previously, `mbedtls_x509_crt_cache_provide_frame()` provided the requested CRT frame by always parsing the raw data underlying the CRT. That's inefficient in legacy mode, where the CRTs fields are permanently accessible through the legacy `mbedtls_x509_crt` structure. This commit modifies `mbedtls_x509_crt_cache_provide_frame()` in legacy mode (that is, !MBEDTLS_X509_ON_DEMAND_PARSING) to setup the CRT frame by copying fields from the legacy CRT structure.
2019-03-04 11:52:23 +00:00
static int x509_crt_frame_parse_ext( mbedtls_x509_crt_frame *frame );
x509_crt.c: Add blank line to increase readability
2019-06-28 09:46:43 +00:00
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
int mbedtls_x509_crt_cache_provide_frame( mbedtls_x509_crt const *crt )
Add internal API for acquire/release of CRT frames and PKs The goal of the subsequent commits is to remove all direct uses of the existing `mbedtls_x509_crt` apart from the `raw` buffer and the linked list `next` pointer. The approach is the following: Whenever a code-path needs to inspect a CRT, it can request a frame for the CRT through the API `x509_crt_frame_acquire()`. On success, this function returns a pointer to a frame structure for the CRT (the origin of which is flexible and need not concern the caller) that can be used to inspect the desired fields. Once done, the caller hands back the frame through an explicit call to `x509_crt_frame_release()`. This commit also adds an inefficient dummy implementation for `x509_crt_frame_acquire()` which always allocates a new `mbedtls_x509_crt_frame` structure on the heap and parses it from the raw data underlying the CRT. This will change in subsequent commits, but it constitutes a valid implementation to test against. Ultimately, `x509_crt_frame_acquire()` is to compute a frame for the given CRT only once, and cache it for subsequent calls. The need for `x509_crt_frame_release()` is the following: When implementing `x509_crt_frame_acquire()` through a flushable cache as indicated above, it must be ensured that no thread destroys a cached frame structure for the time it is needed by another thread. The `acquire/release` pair allows to explicitly delimit the lifetime requirements for the returned frame structure. The frame pointer must not be used after the `release` call anymore; and in fact, the dummy implementation shows that it would immediately lead to a memory failure. Analogously to `x509_crt_frame_{acquire|release}()`, there's also `x509_crt_pk_{acquire|release}()` which allows to acquire/release a PK context setup from the public key contained within the CRT.
2019-02-25 14:53:14 +00:00
{
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
mbedtls_x509_crt_cache *cache = crt->cache;
Add internal API for acquire/release of CRT frames and PKs The goal of the subsequent commits is to remove all direct uses of the existing `mbedtls_x509_crt` apart from the `raw` buffer and the linked list `next` pointer. The approach is the following: Whenever a code-path needs to inspect a CRT, it can request a frame for the CRT through the API `x509_crt_frame_acquire()`. On success, this function returns a pointer to a frame structure for the CRT (the origin of which is flexible and need not concern the caller) that can be used to inspect the desired fields. Once done, the caller hands back the frame through an explicit call to `x509_crt_frame_release()`. This commit also adds an inefficient dummy implementation for `x509_crt_frame_acquire()` which always allocates a new `mbedtls_x509_crt_frame` structure on the heap and parses it from the raw data underlying the CRT. This will change in subsequent commits, but it constitutes a valid implementation to test against. Ultimately, `x509_crt_frame_acquire()` is to compute a frame for the given CRT only once, and cache it for subsequent calls. The need for `x509_crt_frame_release()` is the following: When implementing `x509_crt_frame_acquire()` through a flushable cache as indicated above, it must be ensured that no thread destroys a cached frame structure for the time it is needed by another thread. The `acquire/release` pair allows to explicitly delimit the lifetime requirements for the returned frame structure. The frame pointer must not be used after the `release` call anymore; and in fact, the dummy implementation shows that it would immediately lead to a memory failure. Analogously to `x509_crt_frame_{acquire|release}()`, there's also `x509_crt_pk_{acquire|release}()` which allows to acquire/release a PK context setup from the public key contained within the CRT.
2019-02-25 14:53:14 +00:00
mbedtls_x509_crt_frame *frame;
Move existence check for pk/frame to mbedtls_x509_crt_provide_xxx()
2019-03-05 15:29:23 +00:00
if( cache->frame != NULL )
Don't allow nested CRT acquire()-calls if MBEDTLS_X509_ALWAYS_FLUSH Forbidding nested calls to acquire() allows to remove the reference counting logic and hence saving some bytes of code. This is valuable because MBEDTLS_X509_ALWAYS_FLUSH is likely to be used on constrained systems where code-size is limited.
2019-06-28 13:45:26 +00:00
{
Fix guard controlling whether nested acquire calls are allowed Resource counting as a safe-guard against nested acquire calls is implemented if and only if MBEDTLS_X509_ALWAYS_FLUSH is disabled _or_ MBEDTLS_THREADING_C is enabled.
2019-07-02 12:37:12 +00:00
#if !defined(MBEDTLS_X509_ALWAYS_FLUSH) || \
defined(MBEDTLS_THREADING_C)
Move existence check for pk/frame to mbedtls_x509_crt_provide_xxx()
2019-03-05 15:29:23 +00:00
return( 0 );
Don't allow nested CRT acquire()-calls if MBEDTLS_X509_ALWAYS_FLUSH Forbidding nested calls to acquire() allows to remove the reference counting logic and hence saving some bytes of code. This is valuable because MBEDTLS_X509_ALWAYS_FLUSH is likely to be used on constrained systems where code-size is limited.
2019-06-28 13:45:26 +00:00
#else
/* If MBEDTLS_X509_ALWAYS_FLUSH is set, we don't
* allow nested uses of acquire. */
return( MBEDTLS_ERR_X509_FATAL_ERROR );
#endif
}
Move existence check for pk/frame to mbedtls_x509_crt_provide_xxx()
2019-03-05 15:29:23 +00:00
Add internal API for acquire/release of CRT frames and PKs The goal of the subsequent commits is to remove all direct uses of the existing `mbedtls_x509_crt` apart from the `raw` buffer and the linked list `next` pointer. The approach is the following: Whenever a code-path needs to inspect a CRT, it can request a frame for the CRT through the API `x509_crt_frame_acquire()`. On success, this function returns a pointer to a frame structure for the CRT (the origin of which is flexible and need not concern the caller) that can be used to inspect the desired fields. Once done, the caller hands back the frame through an explicit call to `x509_crt_frame_release()`. This commit also adds an inefficient dummy implementation for `x509_crt_frame_acquire()` which always allocates a new `mbedtls_x509_crt_frame` structure on the heap and parses it from the raw data underlying the CRT. This will change in subsequent commits, but it constitutes a valid implementation to test against. Ultimately, `x509_crt_frame_acquire()` is to compute a frame for the given CRT only once, and cache it for subsequent calls. The need for `x509_crt_frame_release()` is the following: When implementing `x509_crt_frame_acquire()` through a flushable cache as indicated above, it must be ensured that no thread destroys a cached frame structure for the time it is needed by another thread. The `acquire/release` pair allows to explicitly delimit the lifetime requirements for the returned frame structure. The frame pointer must not be used after the `release` call anymore; and in fact, the dummy implementation shows that it would immediately lead to a memory failure. Analogously to `x509_crt_frame_{acquire|release}()`, there's also `x509_crt_pk_{acquire|release}()` which allows to acquire/release a PK context setup from the public key contained within the CRT.
2019-02-25 14:53:14 +00:00
frame = mbedtls_calloc( 1, sizeof( mbedtls_x509_crt_frame ) );
if( frame == NULL )
return( MBEDTLS_ERR_X509_ALLOC_FAILED );
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
cache->frame = frame;
Add internal API for acquire/release of CRT frames and PKs The goal of the subsequent commits is to remove all direct uses of the existing `mbedtls_x509_crt` apart from the `raw` buffer and the linked list `next` pointer. The approach is the following: Whenever a code-path needs to inspect a CRT, it can request a frame for the CRT through the API `x509_crt_frame_acquire()`. On success, this function returns a pointer to a frame structure for the CRT (the origin of which is flexible and need not concern the caller) that can be used to inspect the desired fields. Once done, the caller hands back the frame through an explicit call to `x509_crt_frame_release()`. This commit also adds an inefficient dummy implementation for `x509_crt_frame_acquire()` which always allocates a new `mbedtls_x509_crt_frame` structure on the heap and parses it from the raw data underlying the CRT. This will change in subsequent commits, but it constitutes a valid implementation to test against. Ultimately, `x509_crt_frame_acquire()` is to compute a frame for the given CRT only once, and cache it for subsequent calls. The need for `x509_crt_frame_release()` is the following: When implementing `x509_crt_frame_acquire()` through a flushable cache as indicated above, it must be ensured that no thread destroys a cached frame structure for the time it is needed by another thread. The `acquire/release` pair allows to explicitly delimit the lifetime requirements for the returned frame structure. The frame pointer must not be used after the `release` call anymore; and in fact, the dummy implementation shows that it would immediately lead to a memory failure. Analogously to `x509_crt_frame_{acquire|release}()`, there's also `x509_crt_pk_{acquire|release}()` which allows to acquire/release a PK context setup from the public key contained within the CRT.
2019-02-25 14:53:14 +00:00
Provide direct way of setting up a CRT frame from legacy CRT struct Previously, `mbedtls_x509_crt_cache_provide_frame()` provided the requested CRT frame by always parsing the raw data underlying the CRT. That's inefficient in legacy mode, where the CRTs fields are permanently accessible through the legacy `mbedtls_x509_crt` structure. This commit modifies `mbedtls_x509_crt_cache_provide_frame()` in legacy mode (that is, !MBEDTLS_X509_ON_DEMAND_PARSING) to setup the CRT frame by copying fields from the legacy CRT structure.
2019-03-04 11:52:23 +00:00
#if defined(MBEDTLS_X509_ON_DEMAND_PARSING)
/* This would work with !MBEDTLS_X509_ON_DEMAND_PARSING, too,
* but is inefficient compared to copying the respective fields
* from the legacy mbedtls_x509_crt. */
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
return( x509_crt_parse_frame( crt->raw.p,
crt->raw.p + crt->raw.len,
frame ) );
Provide direct way of setting up a CRT frame from legacy CRT struct Previously, `mbedtls_x509_crt_cache_provide_frame()` provided the requested CRT frame by always parsing the raw data underlying the CRT. That's inefficient in legacy mode, where the CRTs fields are permanently accessible through the legacy `mbedtls_x509_crt` structure. This commit modifies `mbedtls_x509_crt_cache_provide_frame()` in legacy mode (that is, !MBEDTLS_X509_ON_DEMAND_PARSING) to setup the CRT frame by copying fields from the legacy CRT structure.
2019-03-04 11:52:23 +00:00
#else /* MBEDTLS_X509_ON_DEMAND_PARSING */
/* Make sure all extension related fields are properly initialized. */
frame->ca_istrue = 0;
frame->max_pathlen = 0;
frame->ext_types = 0;
frame->version = crt->version;
frame->sig_md = crt->sig_md;
frame->sig_pk = crt->sig_pk;
frame->valid_from = crt->valid_from;
frame->valid_to = crt->valid_to;
Introduce helpers for conversion between X.509 buffer structs This commit introduces two static helpers - `x509_buf_to_buf_raw()` - `x509_buf_raw_to_buf()` which convert to/from the old `mbedtls_x509_buf` and the new `mbedtls_x509_buf_raw` (the latter omitting the ASN.1 tag field).
2019-03-04 15:13:45 +00:00
x509_buf_to_buf_raw( &frame->raw, &crt->raw );
x509_buf_to_buf_raw( &frame->tbs, &crt->tbs );
x509_buf_to_buf_raw( &frame->serial, &crt->serial );
x509_buf_to_buf_raw( &frame->pubkey_raw, &crt->pk_raw );
x509_buf_to_buf_raw( &frame->issuer_raw, &crt->issuer_raw );
x509_buf_to_buf_raw( &frame->subject_raw, &crt->subject_raw );
x509_buf_to_buf_raw( &frame->subject_id, &crt->subject_id );
x509_buf_to_buf_raw( &frame->issuer_id, &crt->issuer_id );
x509_buf_to_buf_raw( &frame->sig, &crt->sig );
x509_buf_to_buf_raw( &frame->v3_ext, &crt->v3_ext );
Provide direct way of setting up a CRT frame from legacy CRT struct Previously, `mbedtls_x509_crt_cache_provide_frame()` provided the requested CRT frame by always parsing the raw data underlying the CRT. That's inefficient in legacy mode, where the CRTs fields are permanently accessible through the legacy `mbedtls_x509_crt` structure. This commit modifies `mbedtls_x509_crt_cache_provide_frame()` in legacy mode (that is, !MBEDTLS_X509_ON_DEMAND_PARSING) to setup the CRT frame by copying fields from the legacy CRT structure.
2019-03-04 11:52:23 +00:00
/* The legacy CRT structure doesn't explicitly contain
* the `AlgorithmIdentifier` bounds; however, those can
* be inferred from the surrounding (mandatory) `SerialNumber`
* and `Issuer` fields. */
frame->sig_alg.p = crt->serial.p + crt->serial.len;
frame->sig_alg.len = crt->issuer_raw.p - frame->sig_alg.p;
return( x509_crt_frame_parse_ext( frame ) );
#endif /* !MBEDTLS_X509_ON_DEMAND_PARSING */
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
}
Add internal API for acquire/release of CRT frames and PKs The goal of the subsequent commits is to remove all direct uses of the existing `mbedtls_x509_crt` apart from the `raw` buffer and the linked list `next` pointer. The approach is the following: Whenever a code-path needs to inspect a CRT, it can request a frame for the CRT through the API `x509_crt_frame_acquire()`. On success, this function returns a pointer to a frame structure for the CRT (the origin of which is flexible and need not concern the caller) that can be used to inspect the desired fields. Once done, the caller hands back the frame through an explicit call to `x509_crt_frame_release()`. This commit also adds an inefficient dummy implementation for `x509_crt_frame_acquire()` which always allocates a new `mbedtls_x509_crt_frame` structure on the heap and parses it from the raw data underlying the CRT. This will change in subsequent commits, but it constitutes a valid implementation to test against. Ultimately, `x509_crt_frame_acquire()` is to compute a frame for the given CRT only once, and cache it for subsequent calls. The need for `x509_crt_frame_release()` is the following: When implementing `x509_crt_frame_acquire()` through a flushable cache as indicated above, it must be ensured that no thread destroys a cached frame structure for the time it is needed by another thread. The `acquire/release` pair allows to explicitly delimit the lifetime requirements for the returned frame structure. The frame pointer must not be used after the `release` call anymore; and in fact, the dummy implementation shows that it would immediately lead to a memory failure. Analogously to `x509_crt_frame_{acquire|release}()`, there's also `x509_crt_pk_{acquire|release}()` which allows to acquire/release a PK context setup from the public key contained within the CRT.
2019-02-25 14:53:14 +00:00
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
int mbedtls_x509_crt_cache_provide_pk( mbedtls_x509_crt const *crt )
{
mbedtls_x509_crt_cache *cache = crt->cache;
mbedtls_pk_context *pk;
Move existence check for pk/frame to mbedtls_x509_crt_provide_xxx()
2019-03-05 15:29:23 +00:00
if( cache->pk != NULL )
Don't allow nested CRT acquire()-calls if MBEDTLS_X509_ALWAYS_FLUSH Forbidding nested calls to acquire() allows to remove the reference counting logic and hence saving some bytes of code. This is valuable because MBEDTLS_X509_ALWAYS_FLUSH is likely to be used on constrained systems where code-size is limited.
2019-06-28 13:45:26 +00:00
{
Fix guard controlling whether nested acquire calls are allowed Resource counting as a safe-guard against nested acquire calls is implemented if and only if MBEDTLS_X509_ALWAYS_FLUSH is disabled _or_ MBEDTLS_THREADING_C is enabled.
2019-07-02 12:37:12 +00:00
#if !defined(MBEDTLS_X509_ALWAYS_FLUSH) || \
defined(MBEDTLS_THREADING_C)
Move existence check for pk/frame to mbedtls_x509_crt_provide_xxx()
2019-03-05 15:29:23 +00:00
return( 0 );
Don't allow nested CRT acquire()-calls if MBEDTLS_X509_ALWAYS_FLUSH Forbidding nested calls to acquire() allows to remove the reference counting logic and hence saving some bytes of code. This is valuable because MBEDTLS_X509_ALWAYS_FLUSH is likely to be used on constrained systems where code-size is limited.
2019-06-28 13:45:26 +00:00
#else
/* If MBEDTLS_X509_ALWAYS_FLUSH is set, we don't
* allow nested uses of acquire. */
return( MBEDTLS_ERR_X509_FATAL_ERROR );
#endif
}
Move existence check for pk/frame to mbedtls_x509_crt_provide_xxx()
2019-03-05 15:29:23 +00:00
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
pk = mbedtls_calloc( 1, sizeof( mbedtls_pk_context ) );
if( pk == NULL )
return( MBEDTLS_ERR_X509_ALLOC_FAILED );
cache->pk = pk;
Add compile-time option to remove legacy CRT fields
2019-02-28 13:23:38 +00:00
#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
*pk = crt->pk;
Add internal API for acquire/release of CRT frames and PKs The goal of the subsequent commits is to remove all direct uses of the existing `mbedtls_x509_crt` apart from the `raw` buffer and the linked list `next` pointer. The approach is the following: Whenever a code-path needs to inspect a CRT, it can request a frame for the CRT through the API `x509_crt_frame_acquire()`. On success, this function returns a pointer to a frame structure for the CRT (the origin of which is flexible and need not concern the caller) that can be used to inspect the desired fields. Once done, the caller hands back the frame through an explicit call to `x509_crt_frame_release()`. This commit also adds an inefficient dummy implementation for `x509_crt_frame_acquire()` which always allocates a new `mbedtls_x509_crt_frame` structure on the heap and parses it from the raw data underlying the CRT. This will change in subsequent commits, but it constitutes a valid implementation to test against. Ultimately, `x509_crt_frame_acquire()` is to compute a frame for the given CRT only once, and cache it for subsequent calls. The need for `x509_crt_frame_release()` is the following: When implementing `x509_crt_frame_acquire()` through a flushable cache as indicated above, it must be ensured that no thread destroys a cached frame structure for the time it is needed by another thread. The `acquire/release` pair allows to explicitly delimit the lifetime requirements for the returned frame structure. The frame pointer must not be used after the `release` call anymore; and in fact, the dummy implementation shows that it would immediately lead to a memory failure. Analogously to `x509_crt_frame_{acquire|release}()`, there's also `x509_crt_pk_{acquire|release}()` which allows to acquire/release a PK context setup from the public key contained within the CRT.
2019-02-25 14:53:14 +00:00
return( 0 );
Add compile-time option to remove legacy CRT fields
2019-02-28 13:23:38 +00:00
#else
{
mbedtls_x509_buf_raw pk_raw = cache->pk_raw;
return( mbedtls_pk_parse_subpubkey( &pk_raw.p,
pk_raw.p + pk_raw.len,
pk ) );
}
#endif /* MBEDTLS_X509_ON_DEMAND_PARSING */
Add internal API for acquire/release of CRT frames and PKs The goal of the subsequent commits is to remove all direct uses of the existing `mbedtls_x509_crt` apart from the `raw` buffer and the linked list `next` pointer. The approach is the following: Whenever a code-path needs to inspect a CRT, it can request a frame for the CRT through the API `x509_crt_frame_acquire()`. On success, this function returns a pointer to a frame structure for the CRT (the origin of which is flexible and need not concern the caller) that can be used to inspect the desired fields. Once done, the caller hands back the frame through an explicit call to `x509_crt_frame_release()`. This commit also adds an inefficient dummy implementation for `x509_crt_frame_acquire()` which always allocates a new `mbedtls_x509_crt_frame` structure on the heap and parses it from the raw data underlying the CRT. This will change in subsequent commits, but it constitutes a valid implementation to test against. Ultimately, `x509_crt_frame_acquire()` is to compute a frame for the given CRT only once, and cache it for subsequent calls. The need for `x509_crt_frame_release()` is the following: When implementing `x509_crt_frame_acquire()` through a flushable cache as indicated above, it must be ensured that no thread destroys a cached frame structure for the time it is needed by another thread. The `acquire/release` pair allows to explicitly delimit the lifetime requirements for the returned frame structure. The frame pointer must not be used after the `release` call anymore; and in fact, the dummy implementation shows that it would immediately lead to a memory failure. Analogously to `x509_crt_frame_{acquire|release}()`, there's also `x509_crt_pk_{acquire|release}()` which allows to acquire/release a PK context setup from the public key contained within the CRT.
2019-02-25 14:53:14 +00:00
}
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
static void x509_crt_cache_init( mbedtls_x509_crt_cache *cache )
Add internal API for acquire/release of CRT frames and PKs The goal of the subsequent commits is to remove all direct uses of the existing `mbedtls_x509_crt` apart from the `raw` buffer and the linked list `next` pointer. The approach is the following: Whenever a code-path needs to inspect a CRT, it can request a frame for the CRT through the API `x509_crt_frame_acquire()`. On success, this function returns a pointer to a frame structure for the CRT (the origin of which is flexible and need not concern the caller) that can be used to inspect the desired fields. Once done, the caller hands back the frame through an explicit call to `x509_crt_frame_release()`. This commit also adds an inefficient dummy implementation for `x509_crt_frame_acquire()` which always allocates a new `mbedtls_x509_crt_frame` structure on the heap and parses it from the raw data underlying the CRT. This will change in subsequent commits, but it constitutes a valid implementation to test against. Ultimately, `x509_crt_frame_acquire()` is to compute a frame for the given CRT only once, and cache it for subsequent calls. The need for `x509_crt_frame_release()` is the following: When implementing `x509_crt_frame_acquire()` through a flushable cache as indicated above, it must be ensured that no thread destroys a cached frame structure for the time it is needed by another thread. The `acquire/release` pair allows to explicitly delimit the lifetime requirements for the returned frame structure. The frame pointer must not be used after the `release` call anymore; and in fact, the dummy implementation shows that it would immediately lead to a memory failure. Analogously to `x509_crt_frame_{acquire|release}()`, there's also `x509_crt_pk_{acquire|release}()` which allows to acquire/release a PK context setup from the public key contained within the CRT.
2019-02-25 14:53:14 +00:00
{
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
memset( cache, 0, sizeof( *cache ) );
#if defined(MBEDTLS_THREADING_C)
mbedtls_mutex_init( &cache->frame_mutex );
mbedtls_mutex_init( &cache->pk_mutex );
#endif
Add internal API for acquire/release of CRT frames and PKs The goal of the subsequent commits is to remove all direct uses of the existing `mbedtls_x509_crt` apart from the `raw` buffer and the linked list `next` pointer. The approach is the following: Whenever a code-path needs to inspect a CRT, it can request a frame for the CRT through the API `x509_crt_frame_acquire()`. On success, this function returns a pointer to a frame structure for the CRT (the origin of which is flexible and need not concern the caller) that can be used to inspect the desired fields. Once done, the caller hands back the frame through an explicit call to `x509_crt_frame_release()`. This commit also adds an inefficient dummy implementation for `x509_crt_frame_acquire()` which always allocates a new `mbedtls_x509_crt_frame` structure on the heap and parses it from the raw data underlying the CRT. This will change in subsequent commits, but it constitutes a valid implementation to test against. Ultimately, `x509_crt_frame_acquire()` is to compute a frame for the given CRT only once, and cache it for subsequent calls. The need for `x509_crt_frame_release()` is the following: When implementing `x509_crt_frame_acquire()` through a flushable cache as indicated above, it must be ensured that no thread destroys a cached frame structure for the time it is needed by another thread. The `acquire/release` pair allows to explicitly delimit the lifetime requirements for the returned frame structure. The frame pointer must not be used after the `release` call anymore; and in fact, the dummy implementation shows that it would immediately lead to a memory failure. Analogously to `x509_crt_frame_{acquire|release}()`, there's also `x509_crt_pk_{acquire|release}()` which allows to acquire/release a PK context setup from the public key contained within the CRT.
2019-02-25 14:53:14 +00:00
}
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
static void x509_crt_cache_clear_pk( mbedtls_x509_crt_cache *cache )
Add internal API for acquire/release of CRT frames and PKs The goal of the subsequent commits is to remove all direct uses of the existing `mbedtls_x509_crt` apart from the `raw` buffer and the linked list `next` pointer. The approach is the following: Whenever a code-path needs to inspect a CRT, it can request a frame for the CRT through the API `x509_crt_frame_acquire()`. On success, this function returns a pointer to a frame structure for the CRT (the origin of which is flexible and need not concern the caller) that can be used to inspect the desired fields. Once done, the caller hands back the frame through an explicit call to `x509_crt_frame_release()`. This commit also adds an inefficient dummy implementation for `x509_crt_frame_acquire()` which always allocates a new `mbedtls_x509_crt_frame` structure on the heap and parses it from the raw data underlying the CRT. This will change in subsequent commits, but it constitutes a valid implementation to test against. Ultimately, `x509_crt_frame_acquire()` is to compute a frame for the given CRT only once, and cache it for subsequent calls. The need for `x509_crt_frame_release()` is the following: When implementing `x509_crt_frame_acquire()` through a flushable cache as indicated above, it must be ensured that no thread destroys a cached frame structure for the time it is needed by another thread. The `acquire/release` pair allows to explicitly delimit the lifetime requirements for the returned frame structure. The frame pointer must not be used after the `release` call anymore; and in fact, the dummy implementation shows that it would immediately lead to a memory failure. Analogously to `x509_crt_frame_{acquire|release}()`, there's also `x509_crt_pk_{acquire|release}()` which allows to acquire/release a PK context setup from the public key contained within the CRT.
2019-02-25 14:53:14 +00:00
{
Add compile-time option to remove legacy CRT fields
2019-02-28 13:23:38 +00:00
#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
/* The cache holds a shallow copy of the PK context
* in the legacy struct, so don't free PK context. */
mbedtls_free( cache->pk );
Add compile-time option to remove legacy CRT fields
2019-02-28 13:23:38 +00:00
#else
mbedtls_pk_free( cache->pk );
mbedtls_free( cache->pk );
#endif /* MBEDTLS_X509_ON_DEMAND_PARSING */
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
cache->pk = NULL;
}
static void x509_crt_cache_clear_frame( mbedtls_x509_crt_cache *cache )
{
mbedtls_free( cache->frame );
cache->frame = NULL;
}
static void x509_crt_cache_free( mbedtls_x509_crt_cache *cache )
{
if( cache == NULL )
return;
#if defined(MBEDTLS_THREADING_C)
mbedtls_mutex_free( &cache->frame_mutex );
mbedtls_mutex_free( &cache->pk_mutex );
#endif
x509_crt_cache_clear_frame( cache );
x509_crt_cache_clear_pk( cache );
memset( cache, 0, sizeof( *cache ) );
Add internal API for acquire/release of CRT frames and PKs The goal of the subsequent commits is to remove all direct uses of the existing `mbedtls_x509_crt` apart from the `raw` buffer and the linked list `next` pointer. The approach is the following: Whenever a code-path needs to inspect a CRT, it can request a frame for the CRT through the API `x509_crt_frame_acquire()`. On success, this function returns a pointer to a frame structure for the CRT (the origin of which is flexible and need not concern the caller) that can be used to inspect the desired fields. Once done, the caller hands back the frame through an explicit call to `x509_crt_frame_release()`. This commit also adds an inefficient dummy implementation for `x509_crt_frame_acquire()` which always allocates a new `mbedtls_x509_crt_frame` structure on the heap and parses it from the raw data underlying the CRT. This will change in subsequent commits, but it constitutes a valid implementation to test against. Ultimately, `x509_crt_frame_acquire()` is to compute a frame for the given CRT only once, and cache it for subsequent calls. The need for `x509_crt_frame_release()` is the following: When implementing `x509_crt_frame_acquire()` through a flushable cache as indicated above, it must be ensured that no thread destroys a cached frame structure for the time it is needed by another thread. The `acquire/release` pair allows to explicitly delimit the lifetime requirements for the returned frame structure. The frame pointer must not be used after the `release` call anymore; and in fact, the dummy implementation shows that it would immediately lead to a memory failure. Analogously to `x509_crt_frame_{acquire|release}()`, there's also `x509_crt_pk_{acquire|release}()` which allows to acquire/release a PK context setup from the public key contained within the CRT.
2019-02-25 14:53:14 +00:00
}
Add public API to query SubjectAltNames and ExtKeyUsage extensions
2019-02-27 17:33:14 +00:00
int mbedtls_x509_crt_get_subject_alt_names( mbedtls_x509_crt const *crt,
mbedtls_x509_sequence **subj_alt )
{
int ret;
Don't allow change of CRT frame returned by x509_crt_frame_acquire()
2019-05-20 15:26:34 +00:00
mbedtls_x509_crt_frame const *frame;
Add public API to query SubjectAltNames and ExtKeyUsage extensions
2019-02-27 17:33:14 +00:00
mbedtls_x509_sequence *seq;
ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
if( ret != 0 )
return( ret );
seq = mbedtls_calloc( 1, sizeof( mbedtls_x509_sequence ) );
if( seq == NULL )
ret = MBEDTLS_ERR_X509_ALLOC_FAILED;
else
ret = x509_crt_subject_alt_from_frame( frame, seq );
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_frame_release( crt );
Add public API to query SubjectAltNames and ExtKeyUsage extensions
2019-02-27 17:33:14 +00:00
*subj_alt = seq;
return( ret );
}
int mbedtls_x509_crt_get_ext_key_usage( mbedtls_x509_crt const *crt,
mbedtls_x509_sequence **ext_key_usage )
{
int ret;
Don't allow change of CRT frame returned by x509_crt_frame_acquire()
2019-05-20 15:26:34 +00:00
mbedtls_x509_crt_frame const *frame;
Add public API to query SubjectAltNames and ExtKeyUsage extensions
2019-02-27 17:33:14 +00:00
mbedtls_x509_sequence *seq;
ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
if( ret != 0 )
return( ret );
seq = mbedtls_calloc( 1, sizeof( mbedtls_x509_sequence ) );
if( seq == NULL )
ret = MBEDTLS_ERR_X509_ALLOC_FAILED;
else
ret = x509_crt_ext_key_usage_from_frame( frame, seq );
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_frame_release( crt );
Add public API to query SubjectAltNames and ExtKeyUsage extensions
2019-02-27 17:33:14 +00:00
*ext_key_usage = seq;
return( ret );
}
Add public API to query subject and issuer from CRT The legacy `mbedtls_x509_crt` contains fields `issuer/subject` which are dynamically allocated linked list presentations of the CRTs issuer and subject names, respectively. The new CRT frame structure `mbedtls_x509_crt_frame`, however, only provides pointers to the raw ASN.1 buffers for the issuer and subject, for reasons of memory usage. For convenience to users that previously used the `issuer`/`subject` fields of `mbedtls_x509_crt`, this commit adds two public API functions `mbedtls_x509_crt_get_subject()` and `mbedtls_x509_crt_get_issuer()` which allow to request the legacy linked list presentation of the CRTs subject / issuer names. Similar to `mbedtls_x509_crt_get_pk()`, the returned names are owned by the user, and must be freed through a call to `mbedtls_x509_name_free()`.
2019-02-26 18:50:49 +00:00
int mbedtls_x509_crt_get_subject( mbedtls_x509_crt const *crt,
mbedtls_x509_name **subject )
{
int ret;
Don't allow change of CRT frame returned by x509_crt_frame_acquire()
2019-05-20 15:26:34 +00:00
mbedtls_x509_crt_frame const *frame;
Add public API to query subject and issuer from CRT The legacy `mbedtls_x509_crt` contains fields `issuer/subject` which are dynamically allocated linked list presentations of the CRTs issuer and subject names, respectively. The new CRT frame structure `mbedtls_x509_crt_frame`, however, only provides pointers to the raw ASN.1 buffers for the issuer and subject, for reasons of memory usage. For convenience to users that previously used the `issuer`/`subject` fields of `mbedtls_x509_crt`, this commit adds two public API functions `mbedtls_x509_crt_get_subject()` and `mbedtls_x509_crt_get_issuer()` which allow to request the legacy linked list presentation of the CRTs subject / issuer names. Similar to `mbedtls_x509_crt_get_pk()`, the returned names are owned by the user, and must be freed through a call to `mbedtls_x509_name_free()`.
2019-02-26 18:50:49 +00:00
mbedtls_x509_name *name;
ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
if( ret != 0 )
return( ret );
name = mbedtls_calloc( 1, sizeof( mbedtls_x509_name ) );
if( name == NULL )
ret = MBEDTLS_ERR_X509_ALLOC_FAILED;
else
ret = x509_crt_subject_from_frame( frame, name );
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_frame_release( crt );
Add public API to query subject and issuer from CRT The legacy `mbedtls_x509_crt` contains fields `issuer/subject` which are dynamically allocated linked list presentations of the CRTs issuer and subject names, respectively. The new CRT frame structure `mbedtls_x509_crt_frame`, however, only provides pointers to the raw ASN.1 buffers for the issuer and subject, for reasons of memory usage. For convenience to users that previously used the `issuer`/`subject` fields of `mbedtls_x509_crt`, this commit adds two public API functions `mbedtls_x509_crt_get_subject()` and `mbedtls_x509_crt_get_issuer()` which allow to request the legacy linked list presentation of the CRTs subject / issuer names. Similar to `mbedtls_x509_crt_get_pk()`, the returned names are owned by the user, and must be freed through a call to `mbedtls_x509_name_free()`.
2019-02-26 18:50:49 +00:00
*subject = name;
return( ret );
}
int mbedtls_x509_crt_get_issuer( mbedtls_x509_crt const *crt,
mbedtls_x509_name **issuer )
{
int ret;
Don't allow change of CRT frame returned by x509_crt_frame_acquire()
2019-05-20 15:26:34 +00:00
mbedtls_x509_crt_frame const *frame;
Add public API to query subject and issuer from CRT The legacy `mbedtls_x509_crt` contains fields `issuer/subject` which are dynamically allocated linked list presentations of the CRTs issuer and subject names, respectively. The new CRT frame structure `mbedtls_x509_crt_frame`, however, only provides pointers to the raw ASN.1 buffers for the issuer and subject, for reasons of memory usage. For convenience to users that previously used the `issuer`/`subject` fields of `mbedtls_x509_crt`, this commit adds two public API functions `mbedtls_x509_crt_get_subject()` and `mbedtls_x509_crt_get_issuer()` which allow to request the legacy linked list presentation of the CRTs subject / issuer names. Similar to `mbedtls_x509_crt_get_pk()`, the returned names are owned by the user, and must be freed through a call to `mbedtls_x509_name_free()`.
2019-02-26 18:50:49 +00:00
mbedtls_x509_name *name;
ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
if( ret != 0 )
return( ret );
name = mbedtls_calloc( 1, sizeof( mbedtls_x509_name ) );
if( name == NULL )
ret = MBEDTLS_ERR_X509_ALLOC_FAILED;
else
ret = x509_crt_issuer_from_frame( frame, name );
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_frame_release( crt );
Add public API to query subject and issuer from CRT The legacy `mbedtls_x509_crt` contains fields `issuer/subject` which are dynamically allocated linked list presentations of the CRTs issuer and subject names, respectively. The new CRT frame structure `mbedtls_x509_crt_frame`, however, only provides pointers to the raw ASN.1 buffers for the issuer and subject, for reasons of memory usage. For convenience to users that previously used the `issuer`/`subject` fields of `mbedtls_x509_crt`, this commit adds two public API functions `mbedtls_x509_crt_get_subject()` and `mbedtls_x509_crt_get_issuer()` which allow to request the legacy linked list presentation of the CRTs subject / issuer names. Similar to `mbedtls_x509_crt_get_pk()`, the returned names are owned by the user, and must be freed through a call to `mbedtls_x509_name_free()`.
2019-02-26 18:50:49 +00:00
*issuer = name;
return( ret );
}
Add public API to query for CRT frame and PK This commit unconditionally adds two convenience API functions: - mbedtls_x509_crt_get_frame() - mbedtls_x509_crt_get_pk() which allow users to extract a CRT frame or PK context from a certificate. The difference with the existing acquire/release API for frame and PK contexts is that in contrast to the latter, the structures returned by the new API are owned by the user (and, in case of the PK context, need to be freed by him). This makes the API easier to use, but comes at the cost of additional memory overhead.
2019-02-28 13:23:58 +00:00
int mbedtls_x509_crt_get_frame( mbedtls_x509_crt const *crt,
mbedtls_x509_crt_frame *dst )
{
int ret;
Don't allow change of CRT frame returned by x509_crt_frame_acquire()
2019-05-20 15:26:34 +00:00
mbedtls_x509_crt_frame const *frame;
Add public API to query for CRT frame and PK This commit unconditionally adds two convenience API functions: - mbedtls_x509_crt_get_frame() - mbedtls_x509_crt_get_pk() which allow users to extract a CRT frame or PK context from a certificate. The difference with the existing acquire/release API for frame and PK contexts is that in contrast to the latter, the structures returned by the new API are owned by the user (and, in case of the PK context, need to be freed by him). This makes the API easier to use, but comes at the cost of additional memory overhead.
2019-02-28 13:23:58 +00:00
ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
if( ret != 0 )
return( ret );
*dst = *frame;
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_frame_release( crt );
Add public API to query for CRT frame and PK This commit unconditionally adds two convenience API functions: - mbedtls_x509_crt_get_frame() - mbedtls_x509_crt_get_pk() which allow users to extract a CRT frame or PK context from a certificate. The difference with the existing acquire/release API for frame and PK contexts is that in contrast to the latter, the structures returned by the new API are owned by the user (and, in case of the PK context, need to be freed by him). This makes the API easier to use, but comes at the cost of additional memory overhead.
2019-02-28 13:23:58 +00:00
return( 0 );
}
int mbedtls_x509_crt_get_pk( mbedtls_x509_crt const *crt,
mbedtls_pk_context *dst )
{
#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
mbedtls_x509_buf_raw pk_raw = crt->cache->pk_raw;
return( mbedtls_pk_parse_subpubkey( &pk_raw.p,
pk_raw.p + pk_raw.len,
dst ) );
#else /* !MBEDTLS_X509_ON_DEMAND_PARSING */
int ret;
mbedtls_pk_context *pk;
ret = mbedtls_x509_crt_pk_acquire( crt, &pk );
if( ret != 0 )
return( ret );
/* Move PK from CRT cache to destination pointer
* to avoid a copy. */
*dst = *pk;
mbedtls_free( crt->cache->pk );
crt->cache->pk = NULL;
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_pk_release( crt );
Add public API to query for CRT frame and PK This commit unconditionally adds two convenience API functions: - mbedtls_x509_crt_get_frame() - mbedtls_x509_crt_get_pk() which allow users to extract a CRT frame or PK context from a certificate. The difference with the existing acquire/release API for frame and PK contexts is that in contrast to the latter, the structures returned by the new API are owned by the user (and, in case of the PK context, need to be freed by him). This makes the API easier to use, but comes at the cost of additional memory overhead.
2019-02-28 13:23:58 +00:00
return( 0 );
#endif /* MBEDTLS_X509_ON_DEMAND_PARSING */
}
Start using an explicit stack for callback info This is the first step towards making verify_chain() iterative. While from a readability point of view the current recursive version is fine, one of the goals of this refactoring is to prepare for restartable ECC integration, which will need the explicit stack anyway.
2017-07-05 11:28:45 +00:00
/*
* Item in a verification chain: cert and flags for it
*/
typedef struct {
mbedtls_x509_crt *crt;
uint32_t flags;
} x509_crt_verify_chain_item;
/*
* Max size of verification chain: end-entity + intermediates + trusted root
*/
#define X509_MAX_VERIFY_CHAIN_SIZE ( MBEDTLS_X509_MAX_INTERMEDIATE_CA + 2 )
Introduce polarssl_zeroize() instead of memset() for zeroization
2014-06-13 15:20:13 +00:00
Add pre-defined profiles for cert verification
2015-06-15 12:34:59 +00:00
/*
* Default profile
*/
const mbedtls_x509_crt_profile mbedtls_x509_crt_profile_default =
{
SHA-1 deprecation: allow it in key exchange By default, keep allowing SHA-1 in key exchange signatures. Disabling it causes compatibility issues, especially with clients that use TLS1.2 but don't send the signature_algorithms extension. SHA-1 is forbidden in certificates by default, since it's vulnerable to offline collision-based attacks.
2017-05-12 11:16:40 +00:00
#if defined(MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_CERTIFICATES)
Remove SHA-1 in TLS by default Default to forbidding the use of SHA-1 in TLS where it is unsafe: for certificate signing, and as the signature hash algorithm for the TLS 1.2 handshake signature. SHA-1 remains allowed in HMAC-SHA-1 in the XXX_SHA ciphersuites and in the PRF for TLS <= 1.1. For easy backward compatibility for use in controlled environments, turn on the MBEDTLS_TLS_DEFAULT_ALLOW_SHA1 compiled-time option.
2017-05-04 14:17:21 +00:00
/* Allow SHA-1 (weak, but still safe in controlled environments) */
Change data structure of profiles to bitfields - allows to express 'none' or 'all' more easily than lists - more compact and easier to declare statically - easier to check too Only drawback: if we ever have more than 32 curves, we'll need an ABI change to make that field a uint64_t.
2015-06-15 13:33:19 +00:00
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA1 ) |
Remove SHA-1 in TLS by default Default to forbidding the use of SHA-1 in TLS where it is unsafe: for certificate signing, and as the signature hash algorithm for the TLS 1.2 handshake signature. SHA-1 remains allowed in HMAC-SHA-1 in the XXX_SHA ciphersuites and in the PRF for TLS <= 1.1. For easy backward compatibility for use in controlled environments, turn on the MBEDTLS_TLS_DEFAULT_ALLOW_SHA1 compiled-time option.
2017-05-04 14:17:21 +00:00
#endif
/* Only SHA-2 hashes */
Change data structure of profiles to bitfields - allows to express 'none' or 'all' more easily than lists - more compact and easier to declare statically - easier to check too Only drawback: if we ever have more than 32 curves, we'll need an ABI change to make that field a uint64_t.
2015-06-15 13:33:19 +00:00
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA224 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA512 ),
0xFFFFFFF, /* Any PK alg */
0xFFFFFFF, /* Any curve */
Add pre-defined profiles for cert verification
2015-06-15 12:34:59 +00:00
2048,
};
/*
* Next-default profile
*/
Change data structure of profiles to bitfields - allows to express 'none' or 'all' more easily than lists - more compact and easier to declare statically - easier to check too Only drawback: if we ever have more than 32 curves, we'll need an ABI change to make that field a uint64_t.
2015-06-15 13:33:19 +00:00
const mbedtls_x509_crt_profile mbedtls_x509_crt_profile_next =
Add pre-defined profiles for cert verification
2015-06-15 12:34:59 +00:00
{
Change data structure of profiles to bitfields - allows to express 'none' or 'all' more easily than lists - more compact and easier to declare statically - easier to check too Only drawback: if we ever have more than 32 curves, we'll need an ABI change to make that field a uint64_t.
2015-06-15 13:33:19 +00:00
/* Hashes from SHA-256 and above */
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA512 ),
0xFFFFFFF, /* Any PK alg */
Add pre-defined profiles for cert verification
2015-06-15 12:34:59 +00:00
#if defined(MBEDTLS_ECP_C)
Change data structure of profiles to bitfields - allows to express 'none' or 'all' more easily than lists - more compact and easier to declare statically - easier to check too Only drawback: if we ever have more than 32 curves, we'll need an ABI change to make that field a uint64_t.
2015-06-15 13:33:19 +00:00
/* Curves at or above 128-bit security level */
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP256R1 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP384R1 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP521R1 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_BP256R1 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_BP384R1 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_BP512R1 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP256K1 ),
Add pre-defined profiles for cert verification
2015-06-15 12:34:59 +00:00
#else
Change data structure of profiles to bitfields - allows to express 'none' or 'all' more easily than lists - more compact and easier to declare statically - easier to check too Only drawback: if we ever have more than 32 curves, we'll need an ABI change to make that field a uint64_t.
2015-06-15 13:33:19 +00:00
0,
Add pre-defined profiles for cert verification
2015-06-15 12:34:59 +00:00
#endif
2048,
};
/*
* NSA Suite B Profile
*/
Change data structure of profiles to bitfields - allows to express 'none' or 'all' more easily than lists - more compact and easier to declare statically - easier to check too Only drawback: if we ever have more than 32 curves, we'll need an ABI change to make that field a uint64_t.
2015-06-15 13:33:19 +00:00
const mbedtls_x509_crt_profile mbedtls_x509_crt_profile_suiteb =
Add pre-defined profiles for cert verification
2015-06-15 12:34:59 +00:00
{
Change data structure of profiles to bitfields - allows to express 'none' or 'all' more easily than lists - more compact and easier to declare statically - easier to check too Only drawback: if we ever have more than 32 curves, we'll need an ABI change to make that field a uint64_t.
2015-06-15 13:33:19 +00:00
/* Only SHA-256 and 384 */
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ),
/* Only ECDSA */
Fix handshake failure in suite B Fix handshake failure where PK key is translated as `MBEDTLS_ECKEY` instead of `MBEDTLS_ECDSA`
2018-02-06 13:59:38 +00:00
MBEDTLS_X509_ID_FLAG( MBEDTLS_PK_ECDSA ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_PK_ECKEY ),
Add pre-defined profiles for cert verification
2015-06-15 12:34:59 +00:00
#if defined(MBEDTLS_ECP_C)
Change data structure of profiles to bitfields - allows to express 'none' or 'all' more easily than lists - more compact and easier to declare statically - easier to check too Only drawback: if we ever have more than 32 curves, we'll need an ABI change to make that field a uint64_t.
2015-06-15 13:33:19 +00:00
/* Only NIST P-256 and P-384 */
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP256R1 ) |
MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP384R1 ),
Add pre-defined profiles for cert verification
2015-06-15 12:34:59 +00:00
#else
Change data structure of profiles to bitfields - allows to express 'none' or 'all' more easily than lists - more compact and easier to declare statically - easier to check too Only drawback: if we ever have more than 32 curves, we'll need an ABI change to make that field a uint64_t.
2015-06-15 13:33:19 +00:00
0,
Add pre-defined profiles for cert verification
2015-06-15 12:34:59 +00:00
#endif
Change data structure of profiles to bitfields - allows to express 'none' or 'all' more easily than lists - more compact and easier to declare statically - easier to check too Only drawback: if we ever have more than 32 curves, we'll need an ABI change to make that field a uint64_t.
2015-06-15 13:33:19 +00:00
0,
Add pre-defined profiles for cert verification
2015-06-15 12:34:59 +00:00
};
Implement cert profile checking
2015-06-15 14:17:55 +00:00
/*
* Check md_alg against profile
Revert to old behaviour of profile_check_key() Was never documented to check for key alg compatibility, so should not start doing so. Just stop relying on the pk_alg argument instead.
2017-10-26 08:24:16 +00:00
* Return 0 if md_alg is acceptable for this profile, -1 otherwise
Implement cert profile checking
2015-06-15 14:17:55 +00:00
*/
static int x509_profile_check_md_alg( const mbedtls_x509_crt_profile *profile,
mbedtls_md_type_t md_alg )
{
Fix undefined shifts - in x509_profile_check_pk_alg - in x509_profile_check_md_alg - in x509_profile_check_key and in ssl_cli.c : unsigned char gets promoted to signed integer
2018-05-11 09:06:29 +00:00
if( md_alg == MBEDTLS_MD_NONE )
return( -1 );
Implement cert profile checking
2015-06-15 14:17:55 +00:00
if( ( profile->allowed_mds & MBEDTLS_X509_ID_FLAG( md_alg ) ) != 0 )
return( 0 );
return( -1 );
}
/*
* Check pk_alg against profile
Revert to old behaviour of profile_check_key() Was never documented to check for key alg compatibility, so should not start doing so. Just stop relying on the pk_alg argument instead.
2017-10-26 08:24:16 +00:00
* Return 0 if pk_alg is acceptable for this profile, -1 otherwise
Implement cert profile checking
2015-06-15 14:17:55 +00:00
*/
static int x509_profile_check_pk_alg( const mbedtls_x509_crt_profile *profile,
mbedtls_pk_type_t pk_alg )
{
Fix undefined shifts - in x509_profile_check_pk_alg - in x509_profile_check_md_alg - in x509_profile_check_key and in ssl_cli.c : unsigned char gets promoted to signed integer
2018-05-11 09:06:29 +00:00
if( pk_alg == MBEDTLS_PK_NONE )
return( -1 );
Implement cert profile checking
2015-06-15 14:17:55 +00:00
if( ( profile->allowed_pks & MBEDTLS_X509_ID_FLAG( pk_alg ) ) != 0 )
return( 0 );
return( -1 );
}
/*
* Check key against profile
Revert to old behaviour of profile_check_key() Was never documented to check for key alg compatibility, so should not start doing so. Just stop relying on the pk_alg argument instead.
2017-10-26 08:24:16 +00:00
* Return 0 if pk is acceptable for this profile, -1 otherwise
Implement cert profile checking
2015-06-15 14:17:55 +00:00
*/
static int x509_profile_check_key( const mbedtls_x509_crt_profile *profile,
const mbedtls_pk_context *pk )
{
Revert to old behaviour of profile_check_key() Was never documented to check for key alg compatibility, so should not start doing so. Just stop relying on the pk_alg argument instead.
2017-10-26 08:24:16 +00:00
const mbedtls_pk_type_t pk_alg = mbedtls_pk_get_type( pk );
Avoid comparing size between RSA and EC keys
2017-10-24 08:51:26 +00:00
Implement cert profile checking
2015-06-15 14:17:55 +00:00
#if defined(MBEDTLS_RSA_C)
if( pk_alg == MBEDTLS_PK_RSA || pk_alg == MBEDTLS_PK_RSASSA_PSS )
{
Rename relevant global symbols from size to bitlen Just applying rename.pl with this file: mbedtls_cipher_get_key_size mbedtls_cipher_get_key_bitlen mbedtls_pk_get_size mbedtls_pk_get_bitlen MBEDTLS_BLOWFISH_MIN_KEY MBEDTLS_BLOWFISH_MIN_KEY_BITS MBEDTLS_BLOWFISH_MAX_KEY MBEDTLS_BLOWFISH_MAX_KEY_BITS
2015-06-18 14:43:38 +00:00
if( mbedtls_pk_get_bitlen( pk ) >= profile->rsa_min_bitlen )
Implement cert profile checking
2015-06-15 14:17:55 +00:00
return( 0 );
return( -1 );
}
#endif
Fix missing check for RSA key length on EE certs - also adapt tests to use lesser requirement for compatibility with old testing material
2015-10-23 12:08:48 +00:00
#if defined(MBEDTLS_ECP_C)
if( pk_alg == MBEDTLS_PK_ECDSA ||
pk_alg == MBEDTLS_PK_ECKEY ||
pk_alg == MBEDTLS_PK_ECKEY_DH )
Implement cert profile checking
2015-06-15 14:17:55 +00:00
{
Revert to old behaviour of profile_check_key() Was never documented to check for key alg compatibility, so should not start doing so. Just stop relying on the pk_alg argument instead.
2017-10-26 08:24:16 +00:00
const mbedtls_ecp_group_id gid = mbedtls_pk_ec( *pk )->grp.id;
Implement cert profile checking
2015-06-15 14:17:55 +00:00
Fix undefined shifts - in x509_profile_check_pk_alg - in x509_profile_check_md_alg - in x509_profile_check_key and in ssl_cli.c : unsigned char gets promoted to signed integer
2018-05-11 09:06:29 +00:00
if( gid == MBEDTLS_ECP_DP_NONE )
return( -1 );
Implement cert profile checking
2015-06-15 14:17:55 +00:00
if( ( profile->allowed_curves & MBEDTLS_X509_ID_FLAG( gid ) ) != 0 )
return( 0 );
return( -1 );
}
#endif
return( -1 );
}
Move static x509_name_cmp() in library/x509_crt.c A subsequent change will need this function earlier within the file.
2018-11-02 09:19:16 +00:00
/*
* Return 0 if name matches wildcard, -1 otherwise
*/
Pass raw data to x509_check_wildcard() and `x509_crt_check_cn()` In preparation for rewriting the `SubjectAlternativeName` search routine to use raw ASN.1 data, this commit changes `x509_check_wildcard()` and `x509_check_cn()`, responsible for checking whether a name matches a wildcard pattern, to take a raw buffer pointer and length as parameters instead of an `mbedtls_x509_buf` instance.
2019-02-21 13:10:55 +00:00
static int x509_check_wildcard( char const *cn,
size_t cn_len,
unsigned char const *buf,
size_t buf_len )
Move static x509_name_cmp() in library/x509_crt.c A subsequent change will need this function earlier within the file.
2018-11-02 09:19:16 +00:00
{
size_t i;
Pass raw data to x509_check_wildcard() and `x509_crt_check_cn()` In preparation for rewriting the `SubjectAlternativeName` search routine to use raw ASN.1 data, this commit changes `x509_check_wildcard()` and `x509_check_cn()`, responsible for checking whether a name matches a wildcard pattern, to take a raw buffer pointer and length as parameters instead of an `mbedtls_x509_buf` instance.
2019-02-21 13:10:55 +00:00
size_t cn_idx = 0;
Move static x509_name_cmp() in library/x509_crt.c A subsequent change will need this function earlier within the file.
2018-11-02 09:19:16 +00:00
/* We can't have a match if there is no wildcard to match */
Pass raw data to x509_check_wildcard() and `x509_crt_check_cn()` In preparation for rewriting the `SubjectAlternativeName` search routine to use raw ASN.1 data, this commit changes `x509_check_wildcard()` and `x509_check_cn()`, responsible for checking whether a name matches a wildcard pattern, to take a raw buffer pointer and length as parameters instead of an `mbedtls_x509_buf` instance.
2019-02-21 13:10:55 +00:00
if( buf_len < 3 || buf[0] != '*' || buf[1] != '.' )
Move static x509_name_cmp() in library/x509_crt.c A subsequent change will need this function earlier within the file.
2018-11-02 09:19:16 +00:00
return( -1 );
for( i = 0; i < cn_len; ++i )
{
if( cn[i] == '.' )
{
cn_idx = i;
break;
}
}
if( cn_idx == 0 )
return( -1 );
Move length check into mbedtls_x509_memcasecmp() At every occasion where we're using `mbedtls_x509_memcasecmp()` we're checking that the two buffer lengths coincide before making the call. This commit saves a few bytes of code by moving this length check to `mbedtls_x509_memcasecmp()`.
2019-02-22 11:46:06 +00:00
if( mbedtls_x509_memcasecmp( buf + 1, cn + cn_idx,
buf_len - 1, cn_len - cn_idx ) == 0 )
Move static x509_name_cmp() in library/x509_crt.c A subsequent change will need this function earlier within the file.
2018-11-02 09:19:16 +00:00
{
return( 0 );
}
return( -1 );
}
Better initialisation of ver_chain Use dedicated function for consistency, and initialise flags to -1 as this is the safe value.
2017-08-23 08:55:41 +00:00
/*
* Reset (init or clear) a verify_chain
*/
static void x509_crt_verify_chain_reset(
mbedtls_x509_crt_verify_chain *ver_chain )
{
size_t i;
for( i = 0; i < MBEDTLS_X509_MAX_VERIFY_CHAIN_SIZE; i++ )
{
ver_chain->items[i].crt = NULL;
Avoid MSVC compiler warning MSVC warns about use of unary `-` operator on unsigned integers.
2019-01-10 09:19:26 +00:00
ver_chain->items[i].flags = (uint32_t) -1;
Better initialisation of ver_chain Use dedicated function for consistency, and initialise flags to -1 as this is the safe value.
2017-08-23 08:55:41 +00:00
}
ver_chain->len = 0;
}
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
/*
* Version ::= INTEGER { v1(0), v2(1), v3(2) }
*/
static int x509_get_version( unsigned char **p,
- Added const-correctness to main codebase
2010-03-16 21:09:09 +00:00
const unsigned char *end,
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
int *ver )
{
- Major type rewrite of int to size_t for most variables and arguments used for buffer lengths and loops
2011-04-24 08:57:21 +00:00
int ret;
size_t len;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0 ) ) != 0 )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
- Minor code cleanup
2011-10-19 14:15:17 +00:00
{
*ver = 0;
return( 0 );
}
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Always return a high-level error code from X.509 module Some functions within the X.509 module return an ASN.1 low level error code where instead this error code should be wrapped by a high-level X.509 error code as in the bulk of the module. Specifically, the following functions are affected: - mbedtls_x509_get_ext() - x509_get_version() - x509_get_uid() This commit modifies these functions to always return an X.509 high level error code. Care has to be taken when adapting `mbetls_x509_get_ext()`: Currently, the callers `mbedtls_x509_crt_ext()` treat the return code `MBEDTLS_ERR_ASN1_UNEXPECTED_TAG` specially to gracefully detect and continue if the extension structure is not present. Wrapping the ASN.1 error with `MBEDTLS_ERR_X509_INVALID_EXTENSIONS` and adapting the check accordingly would mean that an unexpected tag somewhere down the extension parsing would be ignored by the caller. The way out of this is the following: Luckily, the extension structure is always the last field in the surrounding structure, so if there is some data remaining, it must be an Extension structure, so we don't need to deal with a tag mismatch gracefully in the first place. We may therefore wrap the return code from the initial call to `mbedtls_asn1_get_tag()` in `mbedtls_x509_get_ext()` by `MBEDTLS_ERR_X509_INVALID_EXTENSIONS` and simply remove the special treatment of `MBEDTLS_ERR_ASN1_UNEXPECTED_TAG` in the callers `x509_crl_get_ext()` and `x509_crt_get_ext()`. This renders `mbedtls_x509_get_ext()` unsuitable if it ever happened that an Extension structure is optional and does not occur at the end of its surrounding structure, but for CRTs and CRLs, it's fine. The following tests need to be adapted: - "TBSCertificate v3, issuerID wrong tag" The issuerID is optional, so if we look for its presence but find a different tag, we silently continue and try parsing the subjectID, and then the extensions. The tag '00' used in this test doesn't match either of these, and the previous code would hence return LENGTH_MISMATCH after unsucessfully trying issuerID, subjectID and Extensions. With the new code, any data remaining after issuerID and subjectID _must_ be Extension data, so we fail with UNEXPECTED_TAG when trying to parse the Extension data. - "TBSCertificate v3, UIDs, invalid length" The test hardcodes the expectation of MBEDTLS_ERR_ASN1_INVALID_LENGTH, which needs to be wrapped in MBEDTLS_ERR_X509_INVALID_FORMAT now. Fixes #2431.
2019-02-12 11:52:10 +00:00
return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
}
end = *p + len;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ( ret = mbedtls_asn1_get_int( p, end, ver ) ) != 0 )
return( MBEDTLS_ERR_X509_INVALID_VERSION + ret );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
if( *p != end )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_X509_INVALID_VERSION +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
return( 0 );
}
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
/*
* Validity ::= SEQUENCE {
* notBefore Time,
* notAfter Time }
*/
static int x509_get_dates( unsigned char **p,
- Added const-correctness to main codebase
2010-03-16 21:09:09 +00:00
const unsigned char *end,
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_x509_time *from,
mbedtls_x509_time *to )
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
{
- Major type rewrite of int to size_t for most variables and arguments used for buffer lengths and loops
2011-04-24 08:57:21 +00:00
int ret;
size_t len;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
return( MBEDTLS_ERR_X509_INVALID_DATE + ret );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
end = *p + len;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ( ret = mbedtls_x509_get_time( p, end, from ) ) != 0 )
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
return( ret );
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ( ret = mbedtls_x509_get_time( p, end, to ) ) != 0 )
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
return( ret );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
if( *p != end )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_X509_INVALID_DATE +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
return( 0 );
}
/*
* X.509 v2/v3 unique identifier (not parsed)
*/
static int x509_get_uid( unsigned char **p,
- Added const-correctness to main codebase
2010-03-16 21:09:09 +00:00
const unsigned char *end,
Simplify logic for issuer/subject ID parsing
2019-06-07 11:04:39 +00:00
mbedtls_x509_buf_raw *uid, int n )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
{
int ret;
if( *p == end )
return( 0 );
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ( ret = mbedtls_asn1_get_tag( p, end, &uid->len,
MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | n ) ) != 0 )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
return( 0 );
Always return a high-level error code from X.509 module Some functions within the X.509 module return an ASN.1 low level error code where instead this error code should be wrapped by a high-level X.509 error code as in the bulk of the module. Specifically, the following functions are affected: - mbedtls_x509_get_ext() - x509_get_version() - x509_get_uid() This commit modifies these functions to always return an X.509 high level error code. Care has to be taken when adapting `mbetls_x509_get_ext()`: Currently, the callers `mbedtls_x509_crt_ext()` treat the return code `MBEDTLS_ERR_ASN1_UNEXPECTED_TAG` specially to gracefully detect and continue if the extension structure is not present. Wrapping the ASN.1 error with `MBEDTLS_ERR_X509_INVALID_EXTENSIONS` and adapting the check accordingly would mean that an unexpected tag somewhere down the extension parsing would be ignored by the caller. The way out of this is the following: Luckily, the extension structure is always the last field in the surrounding structure, so if there is some data remaining, it must be an Extension structure, so we don't need to deal with a tag mismatch gracefully in the first place. We may therefore wrap the return code from the initial call to `mbedtls_asn1_get_tag()` in `mbedtls_x509_get_ext()` by `MBEDTLS_ERR_X509_INVALID_EXTENSIONS` and simply remove the special treatment of `MBEDTLS_ERR_ASN1_UNEXPECTED_TAG` in the callers `x509_crl_get_ext()` and `x509_crt_get_ext()`. This renders `mbedtls_x509_get_ext()` unsuitable if it ever happened that an Extension structure is optional and does not occur at the end of its surrounding structure, but for CRTs and CRLs, it's fine. The following tests need to be adapted: - "TBSCertificate v3, issuerID wrong tag" The issuerID is optional, so if we look for its presence but find a different tag, we silently continue and try parsing the subjectID, and then the extensions. The tag '00' used in this test doesn't match either of these, and the previous code would hence return LENGTH_MISMATCH after unsucessfully trying issuerID, subjectID and Extensions. With the new code, any data remaining after issuerID and subjectID _must_ be Extension data, so we fail with UNEXPECTED_TAG when trying to parse the Extension data. - "TBSCertificate v3, UIDs, invalid length" The test hardcodes the expectation of MBEDTLS_ERR_ASN1_INVALID_LENGTH, which needs to be wrapped in MBEDTLS_ERR_X509_INVALID_FORMAT now. Fixes #2431.
2019-02-12 11:52:10 +00:00
return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
}
uid->p = *p;
*p += uid->len;
return( 0 );
}
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
static int x509_get_basic_constraints( unsigned char **p,
const unsigned char *end,
int *ca_istrue,
int *max_pathlen )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
{
- Major type rewrite of int to size_t for most variables and arguments used for buffer lengths and loops
2011-04-24 08:57:21 +00:00
int ret;
size_t len;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
/*
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
* BasicConstraints ::= SEQUENCE {
* cA BOOLEAN DEFAULT FALSE,
* pathLenConstraint INTEGER (0..MAX) OPTIONAL }
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*/
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
*ca_istrue = 0; /* DEFAULT FALSE */
*max_pathlen = 0; /* endless */
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
return( ret );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
if( *p == end )
Fix code styling for return statements
2014-06-17 12:06:49 +00:00
return( 0 );
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ( ret = mbedtls_asn1_get_bool( p, end, ca_istrue ) ) != 0 )
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
ret = mbedtls_asn1_get_int( p, end, ca_istrue );
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
if( ret != 0 )
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
return( ret );
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
if( *ca_istrue != 0 )
*ca_istrue = 1;
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
}
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
if( *p == end )
Fix code styling for return statements
2014-06-17 12:06:49 +00:00
return( 0 );
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ( ret = mbedtls_asn1_get_int( p, end, max_pathlen ) ) != 0 )
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
return( ret );
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
if( *p != end )
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
(*max_pathlen)++;
Fix code styling for return statements
2014-06-17 12:06:49 +00:00
return( 0 );
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
}
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
static int x509_get_ns_cert_type( unsigned char **p,
const unsigned char *end,
unsigned char *ns_cert_type)
- Added a separate CRL entry extension parsing function
2011-10-12 09:58:41 +00:00
{
int ret;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_x509_bitstring bs = { 0, 0, NULL };
- Added a separate CRL entry extension parsing function
2011-10-12 09:58:41 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ( ret = mbedtls_asn1_get_bitstring( p, end, &bs ) ) != 0 )
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
return( ret );
- Added a separate CRL entry extension parsing function
2011-10-12 09:58:41 +00:00
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
if( bs.len != 1 )
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
- Improved X509 certificate parsing to include extended certificate fields, such as Key Usage
2011-01-15 16:57:55 +00:00
/* Get actual bitstring */
*ns_cert_type = *bs.p;
Fix code styling for return statements
2014-06-17 12:06:49 +00:00
return( 0 );
- Improved X509 certificate parsing to include extended certificate fields, such as Key Usage
2011-01-15 16:57:55 +00:00
}
static int x509_get_key_usage( unsigned char **p,
const unsigned char *end,
Use uint16_t to store key usage field in X.509 CRT Also, reorder the fields to avoid padding, thereby reducing the size of mbedtls_x509_crt_frame by 2 Bytes.
2019-05-13 11:52:57 +00:00
uint16_t *key_usage)
- Improved X509 certificate parsing to include extended certificate fields, such as Key Usage
2011-01-15 16:57:55 +00:00
{
int ret;
Add parsing/printing for new X.509 keyUsage flags
2015-06-23 08:14:36 +00:00
size_t i;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_x509_bitstring bs = { 0, 0, NULL };
- Improved X509 certificate parsing to include extended certificate fields, such as Key Usage
2011-01-15 16:57:55 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ( ret = mbedtls_asn1_get_bitstring( p, end, &bs ) ) != 0 )
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
return( ret );
- Improved X509 certificate parsing to include extended certificate fields, such as Key Usage
2011-01-15 16:57:55 +00:00
- Correctly handle MS certificate's key usage bits
2012-08-23 13:03:52 +00:00
if( bs.len < 1 )
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
- Improved X509 certificate parsing to include extended certificate fields, such as Key Usage
2011-01-15 16:57:55 +00:00
/* Get actual bitstring */
Add parsing/printing for new X.509 keyUsage flags
2015-06-23 08:14:36 +00:00
*key_usage = 0;
Use uint16_t to store key usage field in X.509 CRT Also, reorder the fields to avoid padding, thereby reducing the size of mbedtls_x509_crt_frame by 2 Bytes.
2019-05-13 11:52:57 +00:00
for( i = 0; i < bs.len && i < sizeof( *key_usage ); i++ )
Add parsing/printing for new X.509 keyUsage flags
2015-06-23 08:14:36 +00:00
{
Use uint16_t to store key usage field in X.509 CRT Also, reorder the fields to avoid padding, thereby reducing the size of mbedtls_x509_crt_frame by 2 Bytes.
2019-05-13 11:52:57 +00:00
*key_usage |= (uint16_t) bs.p[i] << ( 8*i );
Add parsing/printing for new X.509 keyUsage flags
2015-06-23 08:14:36 +00:00
}
Fix code styling for return statements
2014-06-17 12:06:49 +00:00
return( 0 );
- Improved X509 certificate parsing to include extended certificate fields, such as Key Usage
2011-01-15 16:57:55 +00:00
}
Don't use mbedtls_asn1_get_sequence_of() in x509_crt.c This commit modifies the implementation of x509_get_ext_key_usage() to not rely on mbedtls_asn1_get_sequence_of() but to instead use mbedtls_asn1_traverse_sequence_of() with the same sequence-building callback that also x509_get_subject_alt_name() uses, and which agrees with the callback used by mbedtls_asn1_get_sequence_of(). The reason for this is that with this change, Mbed TLS itself isn't using mbedtls_asn1_get_sequence_of() anymore, but only the more powerful mbedtls_asn1_traverse_sequence_of(), so that unless application code makes use of mbedtls_asn1_get_sequence_of(), its implementation -- including the underlying sequence building callback -- will be removed by link time garbage collection.
2019-05-02 13:48:25 +00:00
static int asn1_build_sequence_cb( void *ctx,
int tag,
unsigned char *data,
size_t data_len )
Correct placement of comment on X.509 SAN parsing
2019-05-02 12:21:27 +00:00
{
mbedtls_asn1_sequence **cur_ptr = (mbedtls_asn1_sequence **) ctx;
mbedtls_asn1_sequence *cur = *cur_ptr;
/* Allocate and assign next pointer */
if( cur->buf.p != NULL )
{
cur->next = mbedtls_calloc( 1, sizeof( mbedtls_asn1_sequence ) );
if( cur->next == NULL )
return( MBEDTLS_ERR_ASN1_ALLOC_FAILED );
cur = cur->next;
}
cur->buf.tag = tag;
cur->buf.p = data;
cur->buf.len = data_len;
*cur_ptr = cur;
return( 0 );
}
Don't use mbedtls_asn1_get_sequence_of() in x509_crt.c This commit modifies the implementation of x509_get_ext_key_usage() to not rely on mbedtls_asn1_get_sequence_of() but to instead use mbedtls_asn1_traverse_sequence_of() with the same sequence-building callback that also x509_get_subject_alt_name() uses, and which agrees with the callback used by mbedtls_asn1_get_sequence_of(). The reason for this is that with this change, Mbed TLS itself isn't using mbedtls_asn1_get_sequence_of() anymore, but only the more powerful mbedtls_asn1_traverse_sequence_of(), so that unless application code makes use of mbedtls_asn1_get_sequence_of(), its implementation -- including the underlying sequence building callback -- will be removed by link time garbage collection.
2019-05-02 13:48:25 +00:00
/*
* ExtKeyUsageSyntax ::= SEQUENCE SIZE (1..MAX) OF KeyPurposeId
*
* KeyPurposeId ::= OBJECT IDENTIFIER
*/
static int x509_get_ext_key_usage( unsigned char **p,
const unsigned char *end,
mbedtls_x509_sequence *ext_key_usage)
{
return( mbedtls_asn1_traverse_sequence_of( p, end,
0xFF, MBEDTLS_ASN1_OID,
0, 0,
asn1_build_sequence_cb,
Consistently use (type *) instead of (type*) for pointer conversion
2019-05-29 13:41:44 +00:00
(void *) &ext_key_usage ) );
Don't use mbedtls_asn1_get_sequence_of() in x509_crt.c This commit modifies the implementation of x509_get_ext_key_usage() to not rely on mbedtls_asn1_get_sequence_of() but to instead use mbedtls_asn1_traverse_sequence_of() with the same sequence-building callback that also x509_get_subject_alt_name() uses, and which agrees with the callback used by mbedtls_asn1_get_sequence_of(). The reason for this is that with this change, Mbed TLS itself isn't using mbedtls_asn1_get_sequence_of() anymore, but only the more powerful mbedtls_asn1_traverse_sequence_of(), so that unless application code makes use of mbedtls_asn1_get_sequence_of(), its implementation -- including the underlying sequence building callback -- will be removed by link time garbage collection.
2019-05-02 13:48:25 +00:00
}
- Added support for wildcard certificates - Added support for multi-domain certificates through the X509 Subject Alternative Name extension
2012-02-11 16:09:32 +00:00
/*
* SubjectAltName ::= GeneralNames
*
* GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName
*
* GeneralName ::= CHOICE {
* otherName [0] OtherName,
* rfc822Name [1] IA5String,
* dNSName [2] IA5String,
* x400Address [3] ORAddress,
* directoryName [4] Name,
* ediPartyName [5] EDIPartyName,
* uniformResourceIdentifier [6] IA5String,
* iPAddress [7] OCTET STRING,
* registeredID [8] OBJECT IDENTIFIER }
*
* OtherName ::= SEQUENCE {
* type-id OBJECT IDENTIFIER,
* value [0] EXPLICIT ANY DEFINED BY type-id }
*
* EDIPartyName ::= SEQUENCE {
* nameAssigner [0] DirectoryString OPTIONAL,
* partyName [1] DirectoryString }
*
Rename to mbed TLS in the documentation/comments
2015-01-22 16:11:05 +00:00
* NOTE: we only parse and use dNSName at this point.
- Added support for wildcard certificates - Added support for multi-domain certificates through the X509 Subject Alternative Name extension
2012-02-11 16:09:32 +00:00
*/
Make use of cb to build linked list presentation of SubjectAltName
2019-02-21 14:46:54 +00:00
static int x509_get_subject_alt_name( unsigned char *p,
- Added support for wildcard certificates - Added support for multi-domain certificates through the X509 Subject Alternative Name extension
2012-02-11 16:09:32 +00:00
const unsigned char *end,
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_x509_sequence *subject_alt_name )
- Added support for wildcard certificates - Added support for multi-domain certificates through the X509 Subject Alternative Name extension
2012-02-11 16:09:32 +00:00
{
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
return( mbedtls_asn1_traverse_sequence_of( &p, end,
MBEDTLS_ASN1_TAG_CLASS_MASK,
MBEDTLS_ASN1_CONTEXT_SPECIFIC,
MBEDTLS_ASN1_TAG_VALUE_MASK,
2 /* SubjectAlt DNS */,
Don't use mbedtls_asn1_get_sequence_of() in x509_crt.c This commit modifies the implementation of x509_get_ext_key_usage() to not rely on mbedtls_asn1_get_sequence_of() but to instead use mbedtls_asn1_traverse_sequence_of() with the same sequence-building callback that also x509_get_subject_alt_name() uses, and which agrees with the callback used by mbedtls_asn1_get_sequence_of(). The reason for this is that with this change, Mbed TLS itself isn't using mbedtls_asn1_get_sequence_of() anymore, but only the more powerful mbedtls_asn1_traverse_sequence_of(), so that unless application code makes use of mbedtls_asn1_get_sequence_of(), its implementation -- including the underlying sequence building callback -- will be removed by link time garbage collection.
2019-05-02 13:48:25 +00:00
asn1_build_sequence_cb,
Consistently use (type *) instead of (type*) for pointer conversion
2019-05-29 13:41:44 +00:00
(void *) &subject_alt_name ) );
- Added support for wildcard certificates - Added support for multi-domain certificates through the X509 Subject Alternative Name extension
2012-02-11 16:09:32 +00:00
}
- Improved X509 certificate parsing to include extended certificate fields, such as Key Usage
2011-01-15 16:57:55 +00:00
/*
* X.509 v3 extensions
*
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
*/
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
static int x509_crt_get_ext_cb( void *ctx,
int tag,
unsigned char *p,
size_t ext_len )
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
{
- Major type rewrite of int to size_t for most variables and arguments used for buffer lengths and loops
2011-04-24 08:57:21 +00:00
int ret;
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
mbedtls_x509_crt_frame *frame = (mbedtls_x509_crt_frame *) ctx;
- Major type rewrite of int to size_t for most variables and arguments used for buffer lengths and loops
2011-04-24 08:57:21 +00:00
size_t len;
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
unsigned char *end, *end_ext_octet;
mbedtls_x509_buf extn_oid = { 0, 0, NULL };
int is_critical = 0; /* DEFAULT FALSE */
int ext_type = 0;
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
((void) tag);
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
/*
* Extension ::= SEQUENCE {
* extnID OBJECT IDENTIFIER,
* critical BOOLEAN DEFAULT FALSE,
* extnValue OCTET STRING }
*/
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
end = p + ext_len;
OID functionality moved to a separate module. A new OID module has been created that contains the main OID searching functionality based on type-dependent arrays. A base type is used to contain the basic values (oid_descriptor_t) and that type is extended to contain type specific information (like a pk_alg_t). As a result the rsa sign and verify function prototypes have changed. They now expect a md_type_t identifier instead of the removed RSA_SIG_XXX defines. All OID definitions have been moved to oid.h All OID matching code is in the OID module. The RSA PKCS#1 functions cleaned up as a result and adapted to use the MD layer. The SSL layer cleanup up as a result and adapted to use the MD layer. The X509 parser cleaned up and matches OIDs in certificates with new module and adapted to use the MD layer. The X509 writer cleaned up and adapted to use the MD layer. Apps and tests modified accordingly
2013-04-07 20:00:46 +00:00
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
/* Get extension ID */
if( ( ret = mbedtls_asn1_get_tag( &p, end, &extn_oid.len,
MBEDTLS_ASN1_OID ) ) != 0 )
goto err;
OID functionality moved to a separate module. A new OID module has been created that contains the main OID searching functionality based on type-dependent arrays. A base type is used to contain the basic values (oid_descriptor_t) and that type is extended to contain type specific information (like a pk_alg_t). As a result the rsa sign and verify function prototypes have changed. They now expect a md_type_t identifier instead of the removed RSA_SIG_XXX defines. All OID definitions have been moved to oid.h All OID matching code is in the OID module. The RSA PKCS#1 functions cleaned up as a result and adapted to use the MD layer. The SSL layer cleanup up as a result and adapted to use the MD layer. The X509 parser cleaned up and matches OIDs in certificates with new module and adapted to use the MD layer. The X509 writer cleaned up and adapted to use the MD layer. Apps and tests modified accordingly
2013-04-07 20:00:46 +00:00
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
extn_oid.tag = MBEDTLS_ASN1_OID;
extn_oid.p = p;
p += extn_oid.len;
/* Get optional critical */
if( ( ret = mbedtls_asn1_get_bool( &p, end, &is_critical ) ) != 0 &&
( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ) )
goto err;
OID functionality moved to a separate module. A new OID module has been created that contains the main OID searching functionality based on type-dependent arrays. A base type is used to contain the basic values (oid_descriptor_t) and that type is extended to contain type specific information (like a pk_alg_t). As a result the rsa sign and verify function prototypes have changed. They now expect a md_type_t identifier instead of the removed RSA_SIG_XXX defines. All OID definitions have been moved to oid.h All OID matching code is in the OID module. The RSA PKCS#1 functions cleaned up as a result and adapted to use the MD layer. The SSL layer cleanup up as a result and adapted to use the MD layer. The X509 parser cleaned up and matches OIDs in certificates with new module and adapted to use the MD layer. The X509 writer cleaned up and adapted to use the MD layer. Apps and tests modified accordingly
2013-04-07 20:00:46 +00:00
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
/* Data should be octet string type */
if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
goto err;
Forbid repeated X.509 extensions
2014-11-12 16:47:28 +00:00
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
end_ext_octet = p + len;
if( end_ext_octet != end )
{
ret = MBEDTLS_ERR_ASN1_LENGTH_MISMATCH;
goto err;
}
OID functionality moved to a separate module. A new OID module has been created that contains the main OID searching functionality based on type-dependent arrays. A base type is used to contain the basic values (oid_descriptor_t) and that type is extended to contain type specific information (like a pk_alg_t). As a result the rsa sign and verify function prototypes have changed. They now expect a md_type_t identifier instead of the removed RSA_SIG_XXX defines. All OID definitions have been moved to oid.h All OID matching code is in the OID module. The RSA PKCS#1 functions cleaned up as a result and adapted to use the MD layer. The SSL layer cleanup up as a result and adapted to use the MD layer. The X509 parser cleaned up and matches OIDs in certificates with new module and adapted to use the MD layer. The X509 writer cleaned up and adapted to use the MD layer. Apps and tests modified accordingly
2013-04-07 20:00:46 +00:00
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
/*
* Detect supported extensions
*/
ret = mbedtls_oid_get_x509_ext_type( &extn_oid, &ext_type );
if( ret != 0 )
{
#if !defined(MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
if( is_critical )
OID functionality moved to a separate module. A new OID module has been created that contains the main OID searching functionality based on type-dependent arrays. A base type is used to contain the basic values (oid_descriptor_t) and that type is extended to contain type specific information (like a pk_alg_t). As a result the rsa sign and verify function prototypes have changed. They now expect a md_type_t identifier instead of the removed RSA_SIG_XXX defines. All OID definitions have been moved to oid.h All OID matching code is in the OID module. The RSA PKCS#1 functions cleaned up as a result and adapted to use the MD layer. The SSL layer cleanup up as a result and adapted to use the MD layer. The X509 parser cleaned up and matches OIDs in certificates with new module and adapted to use the MD layer. The X509 writer cleaned up and adapted to use the MD layer. Apps and tests modified accordingly
2013-04-07 20:00:46 +00:00
{
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
/* Data is marked as critical: fail */
ret = MBEDTLS_ERR_ASN1_UNEXPECTED_TAG;
goto err;
}
Add comment to #endif indicating which condition was guarded
2019-05-29 13:43:17 +00:00
#endif /* MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION */
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
return( 0 );
}
/* Forbid repeated extensions */
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
if( ( frame->ext_types & ext_type ) != 0 )
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS );
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
frame->ext_types |= ext_type;
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
switch( ext_type )
{
Fix some X509 macro names For some reason, during the great renaming, some names that should have been prefixed with MBEDTLS_X509_ have only been prefixed with MBEDTLS_
2015-04-20 11:19:02 +00:00
case MBEDTLS_X509_EXT_BASIC_CONSTRAINTS:
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
{
int ca_istrue;
int max_pathlen;
- Improved X509 certificate parsing to include extended certificate fields, such as Key Usage
2011-01-15 16:57:55 +00:00
/* Parse basic constraints */
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
ret = x509_get_basic_constraints( &p, end_ext_octet,
&ca_istrue,
&max_pathlen );
if( ret != 0 )
goto err;
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
frame->ca_istrue = ca_istrue;
frame->max_pathlen = max_pathlen;
OID functionality moved to a separate module. A new OID module has been created that contains the main OID searching functionality based on type-dependent arrays. A base type is used to contain the basic values (oid_descriptor_t) and that type is extended to contain type specific information (like a pk_alg_t). As a result the rsa sign and verify function prototypes have changed. They now expect a md_type_t identifier instead of the removed RSA_SIG_XXX defines. All OID definitions have been moved to oid.h All OID matching code is in the OID module. The RSA PKCS#1 functions cleaned up as a result and adapted to use the MD layer. The SSL layer cleanup up as a result and adapted to use the MD layer. The X509 parser cleaned up and matches OIDs in certificates with new module and adapted to use the MD layer. The X509 writer cleaned up and adapted to use the MD layer. Apps and tests modified accordingly
2013-04-07 20:00:46 +00:00
break;
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
}
OID functionality moved to a separate module. A new OID module has been created that contains the main OID searching functionality based on type-dependent arrays. A base type is used to contain the basic values (oid_descriptor_t) and that type is extended to contain type specific information (like a pk_alg_t). As a result the rsa sign and verify function prototypes have changed. They now expect a md_type_t identifier instead of the removed RSA_SIG_XXX defines. All OID definitions have been moved to oid.h All OID matching code is in the OID module. The RSA PKCS#1 functions cleaned up as a result and adapted to use the MD layer. The SSL layer cleanup up as a result and adapted to use the MD layer. The X509 parser cleaned up and matches OIDs in certificates with new module and adapted to use the MD layer. The X509 writer cleaned up and adapted to use the MD layer. Apps and tests modified accordingly
2013-04-07 20:00:46 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
case MBEDTLS_X509_EXT_KEY_USAGE:
- Improved X509 certificate parsing to include extended certificate fields, such as Key Usage
2011-01-15 16:57:55 +00:00
/* Parse key usage */
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
ret = x509_get_key_usage( &p, end_ext_octet,
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
&frame->key_usage );
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
if( ret != 0 )
goto err;
OID functionality moved to a separate module. A new OID module has been created that contains the main OID searching functionality based on type-dependent arrays. A base type is used to contain the basic values (oid_descriptor_t) and that type is extended to contain type specific information (like a pk_alg_t). As a result the rsa sign and verify function prototypes have changed. They now expect a md_type_t identifier instead of the removed RSA_SIG_XXX defines. All OID definitions have been moved to oid.h All OID matching code is in the OID module. The RSA PKCS#1 functions cleaned up as a result and adapted to use the MD layer. The SSL layer cleanup up as a result and adapted to use the MD layer. The X509 parser cleaned up and matches OIDs in certificates with new module and adapted to use the MD layer. The X509 writer cleaned up and adapted to use the MD layer. Apps and tests modified accordingly
2013-04-07 20:00:46 +00:00
break;
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
case MBEDTLS_X509_EXT_SUBJECT_ALT_NAME:
/* Copy reference to raw subject alt name data. */
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
frame->subject_alt_raw.p = p;
frame->subject_alt_raw.len = end_ext_octet - p;
ret = mbedtls_asn1_traverse_sequence_of( &p, end_ext_octet,
MBEDTLS_ASN1_TAG_CLASS_MASK,
MBEDTLS_ASN1_CONTEXT_SPECIFIC,
MBEDTLS_ASN1_TAG_VALUE_MASK,
2 /* SubjectAlt DNS */,
NULL, NULL );
if( ret != 0 )
goto err;
OID functionality moved to a separate module. A new OID module has been created that contains the main OID searching functionality based on type-dependent arrays. A base type is used to contain the basic values (oid_descriptor_t) and that type is extended to contain type specific information (like a pk_alg_t). As a result the rsa sign and verify function prototypes have changed. They now expect a md_type_t identifier instead of the removed RSA_SIG_XXX defines. All OID definitions have been moved to oid.h All OID matching code is in the OID module. The RSA PKCS#1 functions cleaned up as a result and adapted to use the MD layer. The SSL layer cleanup up as a result and adapted to use the MD layer. The X509 parser cleaned up and matches OIDs in certificates with new module and adapted to use the MD layer. The X509 writer cleaned up and adapted to use the MD layer. Apps and tests modified accordingly
2013-04-07 20:00:46 +00:00
break;
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
case MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE:
/* Parse extended key usage */
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
frame->ext_key_usage_raw.p = p;
frame->ext_key_usage_raw.len = end_ext_octet - p;
if( frame->ext_key_usage_raw.len == 0 )
Make use of cb to build linked list presentation of SubjectAltName
2019-02-21 14:46:54 +00:00
{
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
ret = MBEDTLS_ERR_ASN1_INVALID_LENGTH;
goto err;
Make use of cb to build linked list presentation of SubjectAltName
2019-02-21 14:46:54 +00:00
}
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
/* Check structural sanity of extension. */
ret = mbedtls_asn1_traverse_sequence_of( &p, end_ext_octet,
0xFF, MBEDTLS_ASN1_OID,
0, 0, NULL, NULL );
if( ret != 0 )
goto err;
OID functionality moved to a separate module. A new OID module has been created that contains the main OID searching functionality based on type-dependent arrays. A base type is used to contain the basic values (oid_descriptor_t) and that type is extended to contain type specific information (like a pk_alg_t). As a result the rsa sign and verify function prototypes have changed. They now expect a md_type_t identifier instead of the removed RSA_SIG_XXX defines. All OID definitions have been moved to oid.h All OID matching code is in the OID module. The RSA PKCS#1 functions cleaned up as a result and adapted to use the MD layer. The SSL layer cleanup up as a result and adapted to use the MD layer. The X509 parser cleaned up and matches OIDs in certificates with new module and adapted to use the MD layer. The X509 writer cleaned up and adapted to use the MD layer. Apps and tests modified accordingly
2013-04-07 20:00:46 +00:00
break;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
case MBEDTLS_X509_EXT_NS_CERT_TYPE:
OID functionality moved to a separate module. A new OID module has been created that contains the main OID searching functionality based on type-dependent arrays. A base type is used to contain the basic values (oid_descriptor_t) and that type is extended to contain type specific information (like a pk_alg_t). As a result the rsa sign and verify function prototypes have changed. They now expect a md_type_t identifier instead of the removed RSA_SIG_XXX defines. All OID definitions have been moved to oid.h All OID matching code is in the OID module. The RSA PKCS#1 functions cleaned up as a result and adapted to use the MD layer. The SSL layer cleanup up as a result and adapted to use the MD layer. The X509 parser cleaned up and matches OIDs in certificates with new module and adapted to use the MD layer. The X509 writer cleaned up and adapted to use the MD layer. Apps and tests modified accordingly
2013-04-07 20:00:46 +00:00
/* Parse netscape certificate type */
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
ret = x509_get_ns_cert_type( &p, end_ext_octet,
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
&frame->ns_cert_type );
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
if( ret != 0 )
goto err;
OID functionality moved to a separate module. A new OID module has been created that contains the main OID searching functionality based on type-dependent arrays. A base type is used to contain the basic values (oid_descriptor_t) and that type is extended to contain type specific information (like a pk_alg_t). As a result the rsa sign and verify function prototypes have changed. They now expect a md_type_t identifier instead of the removed RSA_SIG_XXX defines. All OID definitions have been moved to oid.h All OID matching code is in the OID module. The RSA PKCS#1 functions cleaned up as a result and adapted to use the MD layer. The SSL layer cleanup up as a result and adapted to use the MD layer. The X509 parser cleaned up and matches OIDs in certificates with new module and adapted to use the MD layer. The X509 writer cleaned up and adapted to use the MD layer. Apps and tests modified accordingly
2013-04-07 20:00:46 +00:00
break;
default:
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
/*
* If this is a non-critical extension, which the oid layer
* supports, but there isn't an X.509 parser for it,
* skip the extension.
*/
#if !defined(MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
if( is_critical )
return( MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE );
#endif
p = end_ext_octet;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
}
return( 0 );
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
err:
return( ret );
}
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
static int x509_crt_frame_parse_ext( mbedtls_x509_crt_frame *frame )
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
{
int ret;
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
unsigned char *p = frame->v3_ext.p;
unsigned char *end = p + frame->v3_ext.len;
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
if( p == end )
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
return( 0 );
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
ret = mbedtls_asn1_traverse_sequence_of( &p, end,
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
0xFF, MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED,
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
0, 0, x509_crt_get_ext_cb, frame );
Implement v3 Extension parsing through ASN.1 SEQUENCE OF traversal This commit rewrites the v3 ext parsing routine `x509_crt_get_ext_cb()` in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-22 11:09:48 +00:00
if( ret == MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE )
return( ret );
if( ret == MBEDTLS_ERR_X509_INVALID_EXTENSIONS )
return( ret );
if( ret != 0 )
ret += MBEDTLS_ERR_X509_INVALID_EXTENSIONS;
return( ret );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
}
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
static int x509_crt_parse_frame( unsigned char *start,
unsigned char *end,
mbedtls_x509_crt_frame *frame )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
{
- Major type rewrite of int to size_t for most variables and arguments used for buffer lengths and loops
2011-04-24 08:57:21 +00:00
int ret;
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
unsigned char *p;
- Fixed a whole bunch of dependencies on defines between files, examples and tests
2011-05-26 13:16:06 +00:00
size_t len;
Basic parsing of certs signed with RSASSA-PSS
2014-01-22 09:12:57 +00:00
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
mbedtls_x509_buf tmp;
unsigned char *tbs_start;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
mbedtls_x509_buf outer_sig_alg;
size_t inner_sig_alg_len;
unsigned char *inner_sig_alg_start;
- Added input handling for x509parse_crt() - Prevented memory leak by only adding new certificate if needed in x509parse_crt() - Add certificate before parsing if chain is 'full' in x509parse_crt()
2009-03-28 18:52:39 +00:00
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
memset( frame, 0, sizeof( *frame ) );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
/*
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
* Certificate ::= SEQUENCE {
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
* tbsCertificate TBSCertificate,
* signatureAlgorithm AlgorithmIdentifier,
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
* signatureValue BIT STRING
* }
*
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*/
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
p = start;
frame->raw.p = p;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_X509_INVALID_FORMAT );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
}
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
/* NOTE: We are currently not checking that the `Certificate`
* structure spans the entire buffer. */
end = p + len;
frame->raw.len = end - frame->raw.p;
x509: trailing bytes in DER: fix bug Fix bug in mbedtls_x509_crt_parse that caused trailing extra data in the buffer after DER certificates to be included in the raw representation. #377
2016-02-17 14:34:12 +00:00
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
/*
* TBSCertificate ::= SEQUENCE { ...
*/
frame->tbs.p = p;
if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
Add a new X.509 API call for copy-less parsing of CRTs Context: The existing API `mbedtls_x509_parse_crt_der()` for parsing DER encoded X.509 CRTs unconditionally makes creates a copy of the input buffer in RAM. While this comes at the benefit of easy use, -- specifically: allowing the user to free or re-use the input buffer right after the call -- it creates a significant memory overhead, as the CRT is duplicated in memory (at least temporarily). This might not be tolerable a resource constrained device. As a remedy, this commit adds a new X.509 API call `mbedtls_x509_parse_crt_der_nocopy()` which has the same signature as `mbedtls_x509_parse_crt_der()` and almost the same semantics, with one difference: The input buffer must persist and be unmodified for the lifetime of the established instance of `mbedtls_x509_crt`, that is, until `mbedtls_x509_crt_free()` is called.
2019-01-31 08:57:44 +00:00
{
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
return( ret + MBEDTLS_ERR_X509_INVALID_FORMAT );
Add a new X.509 API call for copy-less parsing of CRTs Context: The existing API `mbedtls_x509_parse_crt_der()` for parsing DER encoded X.509 CRTs unconditionally makes creates a copy of the input buffer in RAM. While this comes at the benefit of easy use, -- specifically: allowing the user to free or re-use the input buffer right after the call -- it creates a significant memory overhead, as the CRT is duplicated in memory (at least temporarily). This might not be tolerable a resource constrained device. As a remedy, this commit adds a new X.509 API call `mbedtls_x509_parse_crt_der_nocopy()` which has the same signature as `mbedtls_x509_parse_crt_der()` and almost the same semantics, with one difference: The input buffer must persist and be unmodified for the lifetime of the established instance of `mbedtls_x509_crt`, that is, until `mbedtls_x509_crt_free()` is called.
2019-01-31 08:57:44 +00:00
}
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
tbs_start = p;
/* Breadth-first parsing: Jump over TBS for now. */
p += len;
frame->tbs.len = p - frame->tbs.p;
x509: trailing bytes in DER: fix bug Fix bug in mbedtls_x509_crt_parse that caused trailing extra data in the buffer after DER certificates to be included in the raw representation. #377
2016-02-17 14:34:12 +00:00
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
/*
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
* AlgorithmIdentifier ::= SEQUENCE { ...
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*/
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
outer_sig_alg.p = p;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
{
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
}
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
p += len;
outer_sig_alg.len = p - outer_sig_alg.p;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
/*
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
* signatureValue BIT STRING
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*/
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
ret = mbedtls_x509_get_sig( &p, end, &tmp );
if( ret != 0 )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
return( ret );
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
frame->sig.p = tmp.p;
frame->sig.len = tmp.len;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
/* Check that we consumed the entire `Certificate` structure. */
if( p != end )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
{
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
return( MBEDTLS_ERR_X509_INVALID_FORMAT +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
}
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
/* Parse TBSCertificate structure
*
* TBSCertificate ::= SEQUENCE {
* version [0] EXPLICIT Version DEFAULT v1,
* serialNumber CertificateSerialNumber,
* signature AlgorithmIdentifier,
* issuer Name,
* validity Validity,
* subject Name,
* subjectPublicKeyInfo SubjectPublicKeyInfo,
* issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL,
* -- If present, version MUST be v2 or v3
* subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL,
* -- If present, version MUST be v2 or v3
* extensions [3] EXPLICIT Extensions OPTIONAL
* -- If present, version MUST be v3
* }
*/
end = frame->tbs.p + frame->tbs.len;
p = tbs_start;
Fix potential integer overflow parsing DER CRT This patch prevents a potential signed integer overflow during the certificate version verification checks.
2017-03-09 16:16:11 +00:00
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
/*
* Version ::= INTEGER { v1(0), v2(1), v3(2) }
*/
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
{
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
int version;
ret = x509_get_version( &p, end, &version );
if( ret != 0 )
return( ret );
if( version < 0 || version > 2 )
return( MBEDTLS_ERR_X509_UNKNOWN_VERSION );
frame->version = version + 1;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
}
/*
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
* CertificateSerialNumber ::= INTEGER
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*/
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
ret = mbedtls_x509_get_serial( &p, end, &tmp );
if( ret != 0 )
return( ret );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
frame->serial.p = tmp.p;
frame->serial.len = tmp.len;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
/*
* signature AlgorithmIdentifier
*/
inner_sig_alg_start = p;
ret = mbedtls_x509_get_sig_alg_raw( &p, end, &frame->sig_md,
&frame->sig_pk, NULL );
if( ret != 0 )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
return( ret );
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
inner_sig_alg_len = p - inner_sig_alg_start;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
frame->sig_alg.p = inner_sig_alg_start;
frame->sig_alg.len = inner_sig_alg_len;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
/* Consistency check:
* Inner and outer AlgorithmIdentifier structures must coincide:
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
* Quoting RFC 5280, Section 4.1.1.2:
* This field MUST contain the same algorithm identifier as the
* signature field in the sequence tbsCertificate (Section 4.1.2.3).
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*/
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
if( outer_sig_alg.len != inner_sig_alg_len ||
memcmp( outer_sig_alg.p, inner_sig_alg_start, inner_sig_alg_len ) != 0 )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
{
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
return( MBEDTLS_ERR_X509_SIG_MISMATCH );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
}
/*
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
* issuer Name
*
* Name ::= CHOICE { -- only one possibility for now --
* rdnSequence RDNSequence }
*
* RDNSequence ::= SEQUENCE OF RelativeDistinguishedName
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*/
Solely use raw X.509 name data references including SEQUENCE header So far, the CRT frame structure `mbedtls_x509_crt_frame` used as `issuer_raw` and `subject_raw` the _content_ of the ASN.1 name structure for issuer resp. subject. This was in contrast to the fields `issuer_raw` and `subject_raw` from the legacy `mbedtls_x509_crt` structure, and caused some information duplication by having both variants `xxx_no_hdr` and `xxx_with_hdr` in `mbedtls_x509_crt` and `mbedtls_x509_crt_frame`. This commit removes this mismatch by solely using the legacy form of `issuer_raw` and `subject_raw`, i.e. those _including_ the ASN.1 name header.
2019-03-04 14:43:43 +00:00
frame->issuer_raw.p = p;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE );
if( ret != 0 )
return( ret + MBEDTLS_ERR_X509_INVALID_FORMAT );
p += len;
Solely use raw X.509 name data references including SEQUENCE header So far, the CRT frame structure `mbedtls_x509_crt_frame` used as `issuer_raw` and `subject_raw` the _content_ of the ASN.1 name structure for issuer resp. subject. This was in contrast to the fields `issuer_raw` and `subject_raw` from the legacy `mbedtls_x509_crt` structure, and caused some information duplication by having both variants `xxx_no_hdr` and `xxx_with_hdr` in `mbedtls_x509_crt` and `mbedtls_x509_crt_frame`. This commit removes this mismatch by solely using the legacy form of `issuer_raw` and `subject_raw`, i.e. those _including_ the ASN.1 name header.
2019-03-04 14:43:43 +00:00
frame->issuer_raw.len = p - frame->issuer_raw.p;
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
Add comment about X.509 name comparison of buffer with itself
2019-07-02 15:47:40 +00:00
/* Comparing the raw buffer to itself amounts to structural validation. */
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
ret = mbedtls_x509_name_cmp_raw( &frame->issuer_raw,
&frame->issuer_raw,
NULL, NULL );
if( ret != 0 )
return( ret );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
/*
* Validity ::= SEQUENCE { ...
*/
ret = x509_get_dates( &p, end, &frame->valid_from, &frame->valid_to );
if( ret != 0 )
return( ret );
/*
* subject Name
*
* Name ::= CHOICE { -- only one possibility for now --
* rdnSequence RDNSequence }
*
* RDNSequence ::= SEQUENCE OF RelativeDistinguishedName
*/
Solely use raw X.509 name data references including SEQUENCE header So far, the CRT frame structure `mbedtls_x509_crt_frame` used as `issuer_raw` and `subject_raw` the _content_ of the ASN.1 name structure for issuer resp. subject. This was in contrast to the fields `issuer_raw` and `subject_raw` from the legacy `mbedtls_x509_crt` structure, and caused some information duplication by having both variants `xxx_no_hdr` and `xxx_with_hdr` in `mbedtls_x509_crt` and `mbedtls_x509_crt_frame`. This commit removes this mismatch by solely using the legacy form of `issuer_raw` and `subject_raw`, i.e. those _including_ the ASN.1 name header.
2019-03-04 14:43:43 +00:00
frame->subject_raw.p = p;
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE );
if( ret != 0 )
return( ret + MBEDTLS_ERR_X509_INVALID_FORMAT );
p += len;
Solely use raw X.509 name data references including SEQUENCE header So far, the CRT frame structure `mbedtls_x509_crt_frame` used as `issuer_raw` and `subject_raw` the _content_ of the ASN.1 name structure for issuer resp. subject. This was in contrast to the fields `issuer_raw` and `subject_raw` from the legacy `mbedtls_x509_crt` structure, and caused some information duplication by having both variants `xxx_no_hdr` and `xxx_with_hdr` in `mbedtls_x509_crt` and `mbedtls_x509_crt_frame`. This commit removes this mismatch by solely using the legacy form of `issuer_raw` and `subject_raw`, i.e. those _including_ the ASN.1 name header.
2019-03-04 14:43:43 +00:00
frame->subject_raw.len = p - frame->subject_raw.p;
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
Add comment about X.509 name comparison of buffer with itself
2019-07-02 15:47:40 +00:00
/* Comparing the raw buffer to itself amounts to structural validation. */
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
ret = mbedtls_x509_name_cmp_raw( &frame->subject_raw,
&frame->subject_raw,
NULL, NULL );
if( ret != 0 )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
return( ret );
/*
Factor more code into x509_get_pubkey()
2013-07-09 10:13:24 +00:00
* SubjectPublicKeyInfo
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*/
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
frame->pubkey_raw.p = p;
ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE );
if( ret != 0 )
return( ret + MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
p += len;
frame->pubkey_raw.len = p - frame->pubkey_raw.p;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Simplify X.509 CRT version check in UID parsing WHen parsing the CRT version, we already check that version is either 1, 2, or 3, so checking whether version == 2 or version == 3 is equivalent to version != 1.
2019-06-08 06:38:20 +00:00
if( frame->version != 1 )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
{
Remove redundant CRT version check during CRT parsing
2019-06-07 10:47:12 +00:00
/*
* issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL,
* -- If present, version shall be v2 or v3
*/
Simplify logic for issuer/subject ID parsing
2019-06-07 11:04:39 +00:00
ret = x509_get_uid( &p, end, &frame->issuer_id, 1 /* implicit tag */ );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
if( ret != 0 )
return( ret );
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
Remove redundant CRT version check during CRT parsing
2019-06-07 10:47:12 +00:00
/*
* subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL,
* -- If present, version shall be v2 or v3
*/
Simplify logic for issuer/subject ID parsing
2019-06-07 11:04:39 +00:00
ret = x509_get_uid( &p, end, &frame->subject_id, 2 /* implicit tag */ );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
if( ret != 0 )
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
return( ret );
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
}
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
/*
* extensions [3] EXPLICIT Extensions OPTIONAL
* -- If present, version shall be v3
*/
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if !defined(MBEDTLS_X509_ALLOW_EXTENSIONS_NON_V3)
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
if( frame->version == 3 )
Support faulty X509 v1 certificates with extensions (POLARSSL_X509_ALLOW_EXTENSIONS_NON_V3)
2013-09-23 13:01:36 +00:00
#endif
Minor source simplification
2015-03-27 15:15:55 +00:00
{
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
if( p != end )
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
{
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
ret = mbedtls_asn1_get_tag( &p, end, &len,
MBEDTLS_ASN1_CONTEXT_SPECIFIC |
MBEDTLS_ASN1_CONSTRUCTED | 3 );
if( len == 0 )
ret = MBEDTLS_ERR_ASN1_OUT_OF_DATA;
if( ret != 0 )
return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
frame->v3_ext.p = p;
frame->v3_ext.len = len;
p += len;
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
}
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
ret = x509_crt_frame_parse_ext( frame );
if( ret != 0 )
return( ret );
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
}
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
/* Wrapup: Check that we consumed the entire `TBSCertificate` structure. */
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
if( p != end )
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_X509_INVALID_FORMAT +
MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
}
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
return( 0 );
}
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
Mark CRT frame argument to mbedtls_x509_xxx_from_frame() constant
2019-05-13 12:53:21 +00:00
static int x509_crt_subject_from_frame( mbedtls_x509_crt_frame const *frame,
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
mbedtls_x509_name *subject )
{
Solely use raw X.509 name data references including SEQUENCE header So far, the CRT frame structure `mbedtls_x509_crt_frame` used as `issuer_raw` and `subject_raw` the _content_ of the ASN.1 name structure for issuer resp. subject. This was in contrast to the fields `issuer_raw` and `subject_raw` from the legacy `mbedtls_x509_crt` structure, and caused some information duplication by having both variants `xxx_no_hdr` and `xxx_with_hdr` in `mbedtls_x509_crt` and `mbedtls_x509_crt_frame`. This commit removes this mismatch by solely using the legacy form of `issuer_raw` and `subject_raw`, i.e. those _including_ the ASN.1 name header.
2019-03-04 14:43:43 +00:00
return( mbedtls_x509_get_name( frame->subject_raw.p,
frame->subject_raw.len,
subject ) );
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
}
Mark CRT frame argument to mbedtls_x509_xxx_from_frame() constant
2019-05-13 12:53:21 +00:00
static int x509_crt_issuer_from_frame( mbedtls_x509_crt_frame const *frame,
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
mbedtls_x509_name *issuer )
{
Solely use raw X.509 name data references including SEQUENCE header So far, the CRT frame structure `mbedtls_x509_crt_frame` used as `issuer_raw` and `subject_raw` the _content_ of the ASN.1 name structure for issuer resp. subject. This was in contrast to the fields `issuer_raw` and `subject_raw` from the legacy `mbedtls_x509_crt` structure, and caused some information duplication by having both variants `xxx_no_hdr` and `xxx_with_hdr` in `mbedtls_x509_crt` and `mbedtls_x509_crt_frame`. This commit removes this mismatch by solely using the legacy form of `issuer_raw` and `subject_raw`, i.e. those _including_ the ASN.1 name header.
2019-03-04 14:43:43 +00:00
return( mbedtls_x509_get_name( frame->issuer_raw.p,
frame->issuer_raw.len,
issuer ) );
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
}
Mark CRT frame argument to mbedtls_x509_xxx_from_frame() constant
2019-05-13 12:53:21 +00:00
static int x509_crt_subject_alt_from_frame( mbedtls_x509_crt_frame const *frame,
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
mbedtls_x509_sequence *subject_alt )
{
int ret;
unsigned char *p = frame->subject_alt_raw.p;
unsigned char *end = p + frame->subject_alt_raw.len;
memset( subject_alt, 0, sizeof( *subject_alt ) );
if( ( frame->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME ) == 0 )
return( 0 );
ret = x509_get_subject_alt_name( p, end, subject_alt );
if( ret != 0 )
ret += MBEDTLS_ERR_X509_INVALID_EXTENSIONS;
return( ret );
}
Mark CRT frame argument to mbedtls_x509_xxx_from_frame() constant
2019-05-13 12:53:21 +00:00
static int x509_crt_ext_key_usage_from_frame( mbedtls_x509_crt_frame const *frame,
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
mbedtls_x509_sequence *ext_key_usage )
{
int ret;
unsigned char *p = frame->ext_key_usage_raw.p;
unsigned char *end = p + frame->ext_key_usage_raw.len;
memset( ext_key_usage, 0, sizeof( *ext_key_usage ) );
if( ( frame->ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE ) == 0 )
return( 0 );
ret = x509_get_ext_key_usage( &p, end, ext_key_usage );
if( ret != 0 )
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
{
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
ret += MBEDTLS_ERR_X509_INVALID_EXTENSIONS;
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
return( ret );
}
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
return( 0 );
}
Add compile-time option to remove legacy CRT fields
2019-02-28 13:23:38 +00:00
#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
static int x509_crt_pk_from_frame( mbedtls_x509_crt_frame *frame,
mbedtls_pk_context *pk )
{
unsigned char *p = frame->pubkey_raw.p;
unsigned char *end = p + frame->pubkey_raw.len;
return( mbedtls_pk_parse_subpubkey( &p, end, pk ) );
}
Add compile-time option to remove legacy CRT fields
2019-02-28 13:23:38 +00:00
#endif /* !MBEDTLS_X509_ON_DEMAND_PARSING */
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
/*
* Parse and fill a single X.509 certificate in DER format
*/
static int x509_crt_parse_der_core( mbedtls_x509_crt *crt,
const unsigned char *buf,
size_t buflen,
int make_copy )
{
int ret;
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
mbedtls_x509_crt_frame *frame;
mbedtls_x509_crt_cache *cache;
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
if( crt == NULL || buf == NULL )
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
if( make_copy == 0 )
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
{
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
crt->raw.p = (unsigned char*) buf;
crt->raw.len = buflen;
crt->own_buffer = 0;
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
}
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
else
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
{
Avoid allocating empty buffers when handling length-0 CRTs
2019-05-03 11:37:12 +00:00
/* Call mbedtls_calloc with buflen + 1 in order to avoid potential
* return of NULL in case of length 0 certificates, which we want
* to cleanly fail with MBEDTLS_ERR_X509_INVALID_FORMAT in the
* core parsing routine, but not here. */
crt->raw.p = mbedtls_calloc( 1, buflen + 1 );
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
if( crt->raw.p == NULL )
return( MBEDTLS_ERR_X509_ALLOC_FAILED );
crt->raw.len = buflen;
memcpy( crt->raw.p, buf, buflen );
crt->own_buffer = 1;
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
}
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
cache = mbedtls_calloc( 1, sizeof( mbedtls_x509_crt_cache ) );
if( cache == NULL )
{
ret = MBEDTLS_ERR_X509_ALLOC_FAILED;
goto exit;
}
crt->cache = cache;
x509_crt_cache_init( cache );
Provide direct way of setting up a CRT frame from legacy CRT struct Previously, `mbedtls_x509_crt_cache_provide_frame()` provided the requested CRT frame by always parsing the raw data underlying the CRT. That's inefficient in legacy mode, where the CRTs fields are permanently accessible through the legacy `mbedtls_x509_crt` structure. This commit modifies `mbedtls_x509_crt_cache_provide_frame()` in legacy mode (that is, !MBEDTLS_X509_ON_DEMAND_PARSING) to setup the CRT frame by copying fields from the legacy CRT structure.
2019-03-04 11:52:23 +00:00
#if defined(MBEDTLS_X509_ON_DEMAND_PARSING)
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
ret = mbedtls_x509_crt_cache_provide_frame( crt );
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
if( ret != 0 )
goto exit;
Move existence check for pk/frame to mbedtls_x509_crt_provide_xxx()
2019-03-05 15:29:23 +00:00
frame = crt->cache->frame;
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
Provide direct way of setting up a CRT frame from legacy CRT struct Previously, `mbedtls_x509_crt_cache_provide_frame()` provided the requested CRT frame by always parsing the raw data underlying the CRT. That's inefficient in legacy mode, where the CRTs fields are permanently accessible through the legacy `mbedtls_x509_crt` structure. This commit modifies `mbedtls_x509_crt_cache_provide_frame()` in legacy mode (that is, !MBEDTLS_X509_ON_DEMAND_PARSING) to setup the CRT frame by copying fields from the legacy CRT structure.
2019-03-04 11:52:23 +00:00
#else /* MBEDTLS_X509_ON_DEMAND_PARSING */
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
Provide direct way of setting up a CRT frame from legacy CRT struct Previously, `mbedtls_x509_crt_cache_provide_frame()` provided the requested CRT frame by always parsing the raw data underlying the CRT. That's inefficient in legacy mode, where the CRTs fields are permanently accessible through the legacy `mbedtls_x509_crt` structure. This commit modifies `mbedtls_x509_crt_cache_provide_frame()` in legacy mode (that is, !MBEDTLS_X509_ON_DEMAND_PARSING) to setup the CRT frame by copying fields from the legacy CRT structure.
2019-03-04 11:52:23 +00:00
frame = mbedtls_calloc( 1, sizeof( mbedtls_x509_crt_frame ) );
if( frame == NULL )
{
ret = MBEDTLS_ERR_X509_ALLOC_FAILED;
goto exit;
}
cache->frame = frame;
ret = x509_crt_parse_frame( crt->raw.p,
crt->raw.p + crt->raw.len,
frame );
if( ret != 0 )
goto exit;
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
/* Copy frame to legacy CRT structure -- that's inefficient, but if
* memory matters, the new CRT structure should be used anyway. */
Introduce helpers for conversion between X.509 buffer structs This commit introduces two static helpers - `x509_buf_to_buf_raw()` - `x509_buf_raw_to_buf()` which convert to/from the old `mbedtls_x509_buf` and the new `mbedtls_x509_buf_raw` (the latter omitting the ASN.1 tag field).
2019-03-04 15:13:45 +00:00
x509_buf_raw_to_buf( &crt->tbs, &frame->tbs );
x509_buf_raw_to_buf( &crt->serial, &frame->serial );
x509_buf_raw_to_buf( &crt->issuer_raw, &frame->issuer_raw );
x509_buf_raw_to_buf( &crt->subject_raw, &frame->subject_raw );
x509_buf_raw_to_buf( &crt->issuer_id, &frame->issuer_id );
x509_buf_raw_to_buf( &crt->subject_id, &frame->subject_id );
x509_buf_raw_to_buf( &crt->pk_raw, &frame->pubkey_raw );
x509_buf_raw_to_buf( &crt->sig, &frame->sig );
x509_buf_raw_to_buf( &crt->v3_ext, &frame->v3_ext );
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
crt->valid_from = frame->valid_from;
crt->valid_to = frame->valid_to;
crt->version = frame->version;
crt->ca_istrue = frame->ca_istrue;
crt->max_pathlen = frame->max_pathlen;
crt->ext_types = frame->ext_types;
crt->key_usage = frame->key_usage;
crt->ns_cert_type = frame->ns_cert_type;
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
/*
* Obtain the remaining fields from the frame.
*/
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
{
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
/* sig_oid: Previously, needed for convenience in
* mbedtls_x509_crt_info(), now pure legacy burden. */
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
unsigned char *tmp = frame->sig_alg.p;
unsigned char *end = tmp + frame->sig_alg.len;
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
mbedtls_x509_buf sig_oid, sig_params;
ret = mbedtls_x509_get_alg( &tmp, end,
&sig_oid, &sig_params );
if( ret != 0 )
{
/* This should never happen, because we check
* the sanity of the AlgorithmIdentifier structure
* during frame parsing. */
ret = MBEDTLS_ERR_X509_FATAL_ERROR;
goto exit;
}
crt->sig_oid = sig_oid;
/* Signature parameters */
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
tmp = frame->sig_alg.p;
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
ret = mbedtls_x509_get_sig_alg_raw( &tmp, end,
&crt->sig_md, &crt->sig_pk,
&crt->sig_opts );
if( ret != 0 )
{
/* Again, this should never happen. */
ret = MBEDTLS_ERR_X509_FATAL_ERROR;
goto exit;
}
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
}
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
ret = x509_crt_pk_from_frame( frame, &crt->pk );
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
if( ret != 0 )
goto exit;
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
ret = x509_crt_subject_from_frame( frame, &crt->subject );
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
if( ret != 0 )
goto exit;
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
ret = x509_crt_issuer_from_frame( frame, &crt->issuer );
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
if( ret != 0 )
goto exit;
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
ret = x509_crt_subject_alt_from_frame( frame, &crt->subject_alt_names );
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
if( ret != 0 )
goto exit;
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
ret = x509_crt_ext_key_usage_from_frame( frame, &crt->ext_key_usage );
if( ret != 0 )
goto exit;
Add compile-time option to remove legacy CRT fields
2019-02-28 13:23:38 +00:00
#endif /* !MBEDTLS_X509_ON_DEMAND_PARSING */
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
Provide direct way of setting up a CRT frame from legacy CRT struct Previously, `mbedtls_x509_crt_cache_provide_frame()` provided the requested CRT frame by always parsing the raw data underlying the CRT. That's inefficient in legacy mode, where the CRTs fields are permanently accessible through the legacy `mbedtls_x509_crt` structure. This commit modifies `mbedtls_x509_crt_cache_provide_frame()` in legacy mode (that is, !MBEDTLS_X509_ON_DEMAND_PARSING) to setup the CRT frame by copying fields from the legacy CRT structure.
2019-03-04 11:52:23 +00:00
/* Currently, we accept DER encoded CRTs with trailing garbage
* and promise to not account for the garbage in the `raw` field.
*
* Note that this means that `crt->raw.len` is not necessarily the
* full size of the heap buffer allocated at `crt->raw.p` in case
* of copy-mode, but this is not a problem: freeing the buffer doesn't
* need the size, and the garbage data doesn't need zeroization. */
crt->raw.len = frame->raw.len;
cache->pk_raw = frame->pubkey_raw;
Flush CRT cache after parsing This commit modifies the CRT parsing routine to flush the CRT cache after parsing. More specifically, the frame cache is flushed before the PK is parsed, to avoid storing the PK and frame in RAM at the same time.
2019-02-27 13:12:24 +00:00
/* Free the frame before parsing the public key to
* keep peak RAM usage low. This is slightly inefficient
* because the frame will need to be parsed again on the
* first usage of the CRT, but that seems acceptable.
* As soon as the frame gets used multiple times, it
* will be cached by default. */
x509_crt_cache_clear_frame( crt->cache );
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
/* The cache just references the PK structure from the legacy
* implementation, so set up the latter first before setting up
Flush CRT cache after parsing This commit modifies the CRT parsing routine to flush the CRT cache after parsing. More specifically, the frame cache is flushed before the PK is parsed, to avoid storing the PK and frame in RAM at the same time.
2019-02-27 13:12:24 +00:00
* the cache.
*
* We're not actually using the parsed PK context here;
* we just parse it to check that it's well-formed. */
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
ret = mbedtls_x509_crt_cache_provide_pk( crt );
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
if( ret != 0 )
goto exit;
Flush CRT cache after parsing This commit modifies the CRT parsing routine to flush the CRT cache after parsing. More specifically, the frame cache is flushed before the PK is parsed, to avoid storing the PK and frame in RAM at the same time.
2019-02-27 13:12:24 +00:00
x509_crt_cache_clear_pk( crt->cache );
Introduce X.509 CRT frame structure This commit restructures the parsing of X.509 CRTs in the following way: First, it introduces a 'frame' structure `mbedtls_x509_crt_frame`, which contains pointers to some structured fields of a CRT as well as copies of primitive fields. For example, there's a pointer-length pair delimiting the raw public key data in the CRT, but there's a C-uint8 to store the CRT version (not a pointer-length pair delimiting the ASN.1 structure holding the version). Setting up a frame from a raw CRT buffer does not require any memory outside of the frame structure itself; it's just attaches a 'template' to the buffer that allows to inspect the structured parts of the CRT afterwards. Note that the frame structure does not correspond to a particular ASN.1 structure; for example, it contains pointers to delimit the three parts of a CRT (TBS, SignatureAlgorithm, Signature), but also pointers to the fields of the TBS, and pointers into the Extensions substructure of the TBS. Further, the commit introduces an internal function `x509_crt_parse_frame()` which sets up a frame from a raw CRT buffer, as well as several small helper functions which help setting up the more complex structures (Subject, Issuer, PK) from the frame. These functions are then put to use to rewrite the existing parsing function `mbedtls_x509_crt_parse_der_core()` by setting up a CRT frame from the input buffer, residing on the stack, and afterwards copying the respective fields to the actual `mbedtls_x509_crt` structure and performing the deeper parsing through the various helper functions.
2019-02-15 15:27:59 +00:00
exit:
if( ret != 0 )
mbedtls_x509_crt_free( crt );
return( ret );
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
}
/*
* Parse one X.509 certificate in DER format from a buffer and add them to a
* chained list
*/
Add a new X.509 API call for copy-less parsing of CRTs Context: The existing API `mbedtls_x509_parse_crt_der()` for parsing DER encoded X.509 CRTs unconditionally makes creates a copy of the input buffer in RAM. While this comes at the benefit of easy use, -- specifically: allowing the user to free or re-use the input buffer right after the call -- it creates a significant memory overhead, as the CRT is duplicated in memory (at least temporarily). This might not be tolerable a resource constrained device. As a remedy, this commit adds a new X.509 API call `mbedtls_x509_parse_crt_der_nocopy()` which has the same signature as `mbedtls_x509_parse_crt_der()` and almost the same semantics, with one difference: The input buffer must persist and be unmodified for the lifetime of the established instance of `mbedtls_x509_crt`, that is, until `mbedtls_x509_crt_free()` is called.
2019-01-31 08:57:44 +00:00
static int mbedtls_x509_crt_parse_der_internal( mbedtls_x509_crt *chain,
const unsigned char *buf,
size_t buflen,
int make_copy )
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
{
int ret;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_x509_crt *crt = chain, *prev = NULL;
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
/*
* Check for valid input
*/
if( crt == NULL || buf == NULL )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
Determine whether CRT is initialized or not through raw data pointer Previously, `mbedtls_x509_crt_der_internal()` used the `version` field (which is `0` after initialization but strictly greater than 0 once a CRT has successfully been parsed) to determine whether an `mbedtls_x509_crt` instance had already been setup. Preparating for the removal of `version` from the structure, this commit modifies the code to instead peek at the raw data pointer, which is NULL as long as the CRT structure hasn't been setup with a CRT, and will be kept in the new CRT structure.
2019-02-25 18:08:59 +00:00
while( crt->raw.p != NULL && crt->next != NULL )
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
{
prev = crt;
crt = crt->next;
}
/*
* Add new certificate on the end of the chain if needed.
*/
Determine whether CRT is initialized or not through raw data pointer Previously, `mbedtls_x509_crt_der_internal()` used the `version` field (which is `0` after initialization but strictly greater than 0 once a CRT has successfully been parsed) to determine whether an `mbedtls_x509_crt` instance had already been setup. Preparating for the removal of `version` from the structure, this commit modifies the code to instead peek at the raw data pointer, which is NULL as long as the CRT structure hasn't been setup with a CRT, and will be kept in the new CRT structure.
2019-02-25 18:08:59 +00:00
if( crt->raw.p != NULL && crt->next == NULL )
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
{
Replace malloc with calloc - platform layer currently broken (not adapted yet) - memmory_buffer_alloc too
2015-05-26 14:04:06 +00:00
crt->next = mbedtls_calloc( 1, sizeof( mbedtls_x509_crt ) );
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
if( crt->next == NULL )
Rename ERR_xxx_MALLOC_FAILED to ..._ALLOC_FAILED
2015-05-28 07:33:39 +00:00
return( MBEDTLS_ERR_X509_ALLOC_FAILED );
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
prev = crt;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_x509_crt_init( crt->next );
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
crt = crt->next;
}
Add a new X.509 API call for copy-less parsing of CRTs Context: The existing API `mbedtls_x509_parse_crt_der()` for parsing DER encoded X.509 CRTs unconditionally makes creates a copy of the input buffer in RAM. While this comes at the benefit of easy use, -- specifically: allowing the user to free or re-use the input buffer right after the call -- it creates a significant memory overhead, as the CRT is duplicated in memory (at least temporarily). This might not be tolerable a resource constrained device. As a remedy, this commit adds a new X.509 API call `mbedtls_x509_parse_crt_der_nocopy()` which has the same signature as `mbedtls_x509_parse_crt_der()` and almost the same semantics, with one difference: The input buffer must persist and be unmodified for the lifetime of the established instance of `mbedtls_x509_crt`, that is, until `mbedtls_x509_crt_free()` is called.
2019-01-31 08:57:44 +00:00
if( ( ret = x509_crt_parse_der_core( crt, buf, buflen, make_copy ) ) != 0 )
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
{
if( prev )
prev->next = NULL;
if( crt != chain )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_free( crt );
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
return( ret );
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
}
return( 0 );
}
Add a new X.509 API call for copy-less parsing of CRTs Context: The existing API `mbedtls_x509_parse_crt_der()` for parsing DER encoded X.509 CRTs unconditionally makes creates a copy of the input buffer in RAM. While this comes at the benefit of easy use, -- specifically: allowing the user to free or re-use the input buffer right after the call -- it creates a significant memory overhead, as the CRT is duplicated in memory (at least temporarily). This might not be tolerable a resource constrained device. As a remedy, this commit adds a new X.509 API call `mbedtls_x509_parse_crt_der_nocopy()` which has the same signature as `mbedtls_x509_parse_crt_der()` and almost the same semantics, with one difference: The input buffer must persist and be unmodified for the lifetime of the established instance of `mbedtls_x509_crt`, that is, until `mbedtls_x509_crt_free()` is called.
2019-01-31 08:57:44 +00:00
int mbedtls_x509_crt_parse_der_nocopy( mbedtls_x509_crt *chain,
const unsigned char *buf,
size_t buflen )
{
return( mbedtls_x509_crt_parse_der_internal( chain, buf, buflen, 0 ) );
}
int mbedtls_x509_crt_parse_der( mbedtls_x509_crt *chain,
const unsigned char *buf,
size_t buflen )
{
return( mbedtls_x509_crt_parse_der_internal( chain, buf, buflen, 1 ) );
}
- Moved file loading to load_file
2009-04-19 18:44:26 +00:00
/*
Fix formatting: fix some 'easy' > 80 length lines
2014-05-01 12:18:25 +00:00
* Parse one or more PEM certificates from a buffer and add them to the chained
* list
- Moved file loading to load_file
2009-04-19 18:44:26 +00:00
*/
Add a new X.509 API call for copy-less parsing of CRTs Context: The existing API `mbedtls_x509_parse_crt_der()` for parsing DER encoded X.509 CRTs unconditionally makes creates a copy of the input buffer in RAM. While this comes at the benefit of easy use, -- specifically: allowing the user to free or re-use the input buffer right after the call -- it creates a significant memory overhead, as the CRT is duplicated in memory (at least temporarily). This might not be tolerable a resource constrained device. As a remedy, this commit adds a new X.509 API call `mbedtls_x509_parse_crt_der_nocopy()` which has the same signature as `mbedtls_x509_parse_crt_der()` and almost the same semantics, with one difference: The input buffer must persist and be unmodified for the lifetime of the established instance of `mbedtls_x509_crt`, that is, until `mbedtls_x509_crt_free()` is called.
2019-01-31 08:57:44 +00:00
int mbedtls_x509_crt_parse( mbedtls_x509_crt *chain,
const unsigned char *buf,
size_t buflen )
- Moved file loading to load_file
2009-04-19 18:44:26 +00:00
{
Address user reported coverity issues.
2016-05-31 13:03:54 +00:00
#if defined(MBEDTLS_PEM_PARSE_C)
Fix unused variable/function compilation warnings This PR fixes a number of unused variable/function compilation warnings that arise when using a config.h that does not define the macro MBEDTLS_PEM_PARSE_C.
2016-12-07 15:05:53 +00:00
int success = 0, first_error = 0, total_failed = 0;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
int buf_format = MBEDTLS_X509_FORMAT_DER;
Address user reported coverity issues.
2016-05-31 13:03:54 +00:00
#endif
- Moved file loading to load_file
2009-04-19 18:44:26 +00:00
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
/*
* Check for valid input
*/
if( chain == NULL || buf == NULL )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
- Moved file loading to load_file
2009-04-19 18:44:26 +00:00
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
/*
* Determine buffer content. Buffer contains either one DER certificate or
* one or more PEM certificates.
*/
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_PEM_PARSE_C)
Fix checks for nul-termination
2015-05-12 10:43:54 +00:00
if( buflen != 0 && buf[buflen - 1] == '\0' &&
Fix use of pem_read_buffer() in PK, DHM and X509
2015-05-12 09:20:10 +00:00
strstr( (const char *) buf, "-----BEGIN CERTIFICATE-----" ) != NULL )
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
buf_format = MBEDTLS_X509_FORMAT_PEM;
Fix use of pem_read_buffer() in PK, DHM and X509
2015-05-12 09:20:10 +00:00
}
- Moved file loading to load_file
2009-04-19 18:44:26 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( buf_format == MBEDTLS_X509_FORMAT_DER )
return mbedtls_x509_crt_parse_der( chain, buf, buflen );
Address user reported coverity issues.
2016-05-31 13:03:54 +00:00
#else
return mbedtls_x509_crt_parse_der( chain, buf, buflen );
#endif
Fixed potential negative value misinterpretation in load_file()
2013-08-19 12:29:31 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_PEM_PARSE_C)
if( buf_format == MBEDTLS_X509_FORMAT_PEM )
Possible resource leak on FILE* removed in X509 parse
2013-05-14 11:26:51 +00:00
{
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
int ret;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_pem_context pem;
- Moved file loading to load_file
2009-04-19 18:44:26 +00:00
Fix use of pem_read_buffer() in PK, DHM and X509
2015-05-12 09:20:10 +00:00
/* 1 rather than 0 since the terminating NULL byte is counted in */
while( buflen > 1 )
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
{
size_t use_len;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_pem_init( &pem );
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
Fix use of pem_read_buffer() in PK, DHM and X509
2015-05-12 09:20:10 +00:00
/* If we get there, we know the string is null-terminated */
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_pem_read_buffer( &pem,
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
"-----BEGIN CERTIFICATE-----",
"-----END CERTIFICATE-----",
buf, NULL, 0, &use_len );
if( ret == 0 )
{
/*
* Was PEM encoded
*/
buflen -= use_len;
buf += use_len;
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
else if( ret == MBEDTLS_ERR_PEM_BAD_INPUT_DATA )
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
{
return( ret );
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_pem_free( &pem );
- Moved file loading to load_file
2009-04-19 18:44:26 +00:00
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
/*
* PEM header and footer were found
*/
buflen -= use_len;
buf += use_len;
- Moved file loading to load_file
2009-04-19 18:44:26 +00:00
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
if( first_error == 0 )
first_error = ret;
- Moved file loading to load_file
2009-04-19 18:44:26 +00:00
x509_crt_parse() did not increase total_failed on PEM error Result was that PEM errors in files with multiple certificates were not detectable by the user.
2014-09-26 12:53:04 +00:00
total_failed++;
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
continue;
}
else
break;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_x509_crt_parse_der( chain, pem.buf, pem.buflen );
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_pem_free( &pem );
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
if( ret != 0 )
{
/*
* Quit parsing on a memory error
*/
Rename ERR_xxx_MALLOC_FAILED to ..._ALLOC_FAILED
2015-05-28 07:33:39 +00:00
if( ret == MBEDTLS_ERR_X509_ALLOC_FAILED )
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
return( ret );
if( first_error == 0 )
first_error = ret;
total_failed++;
continue;
}
success = 1;
}
}
if( success )
return( total_failed );
else if( first_error )
return( first_error );
else
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_X509_CERT_UNKNOWN_FORMAT );
Address user reported coverity issues.
2016-05-31 13:03:54 +00:00
#endif /* MBEDTLS_PEM_PARSE_C */
- Moved file loading to load_file
2009-04-19 18:44:26 +00:00
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_FS_IO)
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
/*
* Load one or more certificates and add them to the chained list
*/
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
int mbedtls_x509_crt_parse_file( mbedtls_x509_crt *chain, const char *path )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
{
int ret;
size_t n;
unsigned char *buf;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )
- Changed the behaviour of x509parse_parse_crt for permissive parsing. Now returns the number of 'failed certificates' instead of having a switch to enable it. - As a consequence all error code that were positive were changed. A lot of MALLOC_FAILED and FILE_IO_ERROR error codes added for different modules. - Programs and tests were adapted accordingly
2011-12-10 21:55:01 +00:00
return( ret );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_x509_crt_parse( chain, buf, n );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Rename mbedtls_zeroize to mbedtls_platform_zeroize
2018-04-17 14:51:09 +00:00
mbedtls_platform_zeroize( buf, n );
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_free( buf );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
return( ret );
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
int mbedtls_x509_crt_parse_path( mbedtls_x509_crt *chain, const char *path )
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
{
int ret = 0;
Defines for UEFI environment under MSVC added
2013-10-28 17:48:30 +00:00
#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
- Fixed WIN32 version of x509parse_crtpath()
2012-10-01 21:13:10 +00:00
int w_ret;
WCHAR szDir[MAX_PATH];
char filename[MAX_PATH];
Fix formatting: remove trailing spaces, #endif with comments (> 10 lines)
2014-05-01 11:03:14 +00:00
char *p;
Fix potential heap corruption on Windows If len is large enough, when cast to an int it will be negative and then the test if( len > MAX_PATH - 3 ) will not behave as expected.
2015-10-21 08:16:29 +00:00
size_t len = strlen( path );
- Fixed WIN32 version of x509parse_crtpath()
2012-10-01 21:13:10 +00:00
Fix formatting: remove trailing spaces, #endif with comments (> 10 lines)
2014-05-01 11:03:14 +00:00
WIN32_FIND_DATAW file_data;
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
HANDLE hFind;
- Merged fixes 1394 and 1395 from trunk to PolarSSL 1.2 branch
2012-11-02 11:06:08 +00:00
if( len > MAX_PATH - 3 )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
Fix formatting: remove trailing spaces, #endif with comments (> 10 lines)
2014-05-01 11:03:14 +00:00
memset( szDir, 0, sizeof(szDir) );
memset( filename, 0, MAX_PATH );
memcpy( filename, path, len );
filename[len++] = '\\';
p = filename + len;
- Merged fixes 1394 and 1395 from trunk to PolarSSL 1.2 branch
2012-11-02 11:06:08 +00:00
filename[len++] = '*';
- Fixed WIN32 version of x509parse_crtpath()
2012-10-01 21:13:10 +00:00
Fix various compiler warnings with MSVC Fixes various compiler warnings found with Microsoft Visual Studio 2015 (and earlier versions).
2016-11-03 01:11:37 +00:00
w_ret = MultiByteToWideChar( CP_ACP, 0, filename, (int)len, szDir,
Fix formatting: fix some 'easy' > 80 length lines
2014-05-01 12:18:25 +00:00
MAX_PATH - 3 );
Fix unchecked error code on Windows
2015-01-23 17:50:34 +00:00
if( w_ret == 0 )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
- Merged 1397 in branch for 1.2
2012-11-02 12:53:26 +00:00
hFind = FindFirstFileW( szDir, &file_data );
Fix formatting in various code to match spacing from coding style
2014-06-17 14:39:18 +00:00
if( hFind == INVALID_HANDLE_VALUE )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_X509_FILE_IO_ERROR );
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
- Merged fixes 1394 and 1395 from trunk to PolarSSL 1.2 branch
2012-11-02 11:06:08 +00:00
len = MAX_PATH - len;
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
do
{
Fix formatting: remove trailing spaces, #endif with comments (> 10 lines)
2014-05-01 11:03:14 +00:00
memset( p, 0, len );
- Fixed WIN32 version of x509parse_crtpath()
2012-10-01 21:13:10 +00:00
- Bugfix for Windows in cert path handling
2012-06-04 21:29:15 +00:00
if( file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
continue;
Fix formatting: remove trailing spaces, #endif with comments (> 10 lines)
2014-05-01 11:03:14 +00:00
w_ret = WideCharToMultiByte( CP_ACP, 0, file_data.cFileName,
Fix formatting in various code to match spacing from coding style
2014-06-17 14:39:18 +00:00
lstrlenW( file_data.cFileName ),
Fix potential heap corruption on Windows If len is large enough, when cast to an int it will be negative and then the test if( len > MAX_PATH - 3 ) will not behave as expected.
2015-10-21 08:16:29 +00:00
p, (int) len - 1,
Fix formatting: remove trailing spaces, #endif with comments (> 10 lines)
2014-05-01 11:03:14 +00:00
NULL, NULL );
Fix unchecked error code on Windows
2015-01-23 17:50:34 +00:00
if( w_ret == 0 )
Resource leak fix on windows platform Fix a resource leak on windows platform, in mbedtls_x509_crt_parse_path, in case a failure. when an error occurs, goto cleanup, and free the resource, instead of returning error code immediately.
2017-01-09 13:09:16 +00:00
{
ret = MBEDTLS_ERR_X509_FILE_IO_ERROR;
goto cleanup;
}
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
w_ret = mbedtls_x509_crt_parse_file( chain, filename );
- Fixed WIN32 version of x509parse_crtpath()
2012-10-01 21:13:10 +00:00
if( w_ret < 0 )
x509parse_crtpath() is now reentrant and uses more portable stat() Moved from readdir() to readdir_r() and use stat instead of the less portable d_type from struct dirent. (cherry picked from commit cbfcaa9206be586f6bf8ac26586cd63a6c8c8e15)
2013-06-24 17:22:42 +00:00
ret++;
else
ret += w_ret;
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
}
- Merged 1397 in branch for 1.2
2012-11-02 12:53:26 +00:00
while( FindNextFileW( hFind, &file_data ) != 0 );
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
Fix formatting in various code to match spacing from coding style
2014-06-17 14:39:18 +00:00
if( GetLastError() != ERROR_NO_MORE_FILES )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = MBEDTLS_ERR_X509_FILE_IO_ERROR;
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
Resource leak fix on windows platform Fix a resource leak on windows platform, in mbedtls_x509_crt_parse_path, in case a failure. when an error occurs, goto cleanup, and free the resource, instead of returning error code immediately.
2017-01-09 13:09:16 +00:00
cleanup:
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
FindClose( hFind );
Introduced POLARSSL_HAVE_READDIR_R for systems without it
2013-10-14 13:51:50 +00:00
#else /* _WIN32 */
Quit using readdir_r() Prone to buffer overflows on some platforms.
2013-11-26 15:47:11 +00:00
int t_ret;
Allow the entry_name size to be set in config.h Allow the size of the entry_name character array in x509_crt.c to be configurable through a macro in config.h. entry_name holds a path/filename string. The macro introduced in MBEDTLS_X509_MAX_FILE_PATH_LEN.
2016-09-02 13:06:04 +00:00
int snp_ret;
x509parse_crtpath() is now reentrant and uses more portable stat() Moved from readdir() to readdir_r() and use stat instead of the less portable d_type from struct dirent. (cherry picked from commit cbfcaa9206be586f6bf8ac26586cd63a6c8c8e15)
2013-06-24 17:22:42 +00:00
struct stat sb;
Quit using readdir_r() Prone to buffer overflows on some platforms.
2013-11-26 15:47:11 +00:00
struct dirent *entry;
Allow the entry_name size to be set in config.h Allow the size of the entry_name character array in x509_crt.c to be configurable through a macro in config.h. entry_name holds a path/filename string. The macro introduced in MBEDTLS_X509_MAX_FILE_PATH_LEN.
2016-09-02 13:06:04 +00:00
char entry_name[MBEDTLS_X509_MAX_FILE_PATH_LEN];
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
DIR *dir = opendir( path );
Fix formatting in various code to match spacing from coding style
2014-06-17 14:39:18 +00:00
if( dir == NULL )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_X509_FILE_IO_ERROR );
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
Wrong preproccessor condition fix Fix for issue #696 Change #if defined(MBEDTLS_THREADING_PTHREAD) to #if defined(MBEDTLS_THREADING_C)
2017-01-09 17:27:59 +00:00
#if defined(MBEDTLS_THREADING_C)
Allow use of global mutexes with threading_alt
2015-05-27 18:07:18 +00:00
if( ( ret = mbedtls_mutex_lock( &mbedtls_threading_readdir_mutex ) ) != 0 )
Fix potential resource leak in X.509 parse dir Found with fbinfer.
2015-06-22 16:39:57 +00:00
{
closedir( dir );
Mutex x509_crt_parse_path() when pthreads is used
2013-11-28 16:11:54 +00:00
return( ret );
Fix potential resource leak in X.509 parse dir Found with fbinfer.
2015-06-22 16:39:57 +00:00
}
Wrong preproccessor condition fix Fix for issue #696 Change #if defined(MBEDTLS_THREADING_PTHREAD) to #if defined(MBEDTLS_THREADING_C)
2017-01-09 17:27:59 +00:00
#endif /* MBEDTLS_THREADING_C */
Mutex x509_crt_parse_path() when pthreads is used
2013-11-28 16:11:54 +00:00
Quit using readdir_r() Prone to buffer overflows on some platforms.
2013-11-26 15:47:11 +00:00
while( ( entry = readdir( dir ) ) != NULL )
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
{
Allow the entry_name size to be set in config.h Allow the size of the entry_name character array in x509_crt.c to be configurable through a macro in config.h. entry_name holds a path/filename string. The macro introduced in MBEDTLS_X509_MAX_FILE_PATH_LEN.
2016-09-02 13:06:04 +00:00
snp_ret = mbedtls_snprintf( entry_name, sizeof entry_name,
"%s/%s", path, entry->d_name );
x509parse_crtpath() is now reentrant and uses more portable stat() Moved from readdir() to readdir_r() and use stat instead of the less portable d_type from struct dirent. (cherry picked from commit cbfcaa9206be586f6bf8ac26586cd63a6c8c8e15)
2013-06-24 17:22:42 +00:00
Allow the entry_name size to be set in config.h Allow the size of the entry_name character array in x509_crt.c to be configurable through a macro in config.h. entry_name holds a path/filename string. The macro introduced in MBEDTLS_X509_MAX_FILE_PATH_LEN.
2016-09-02 13:06:04 +00:00
if( snp_ret < 0 || (size_t)snp_ret >= sizeof entry_name )
{
ret = MBEDTLS_ERR_X509_BUFFER_TOO_SMALL;
goto cleanup;
}
else if( stat( entry_name, &sb ) == -1 )
Fixed file descriptor leak in x509parse_crtpath()
2013-09-09 15:26:14 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = MBEDTLS_ERR_X509_FILE_IO_ERROR;
Mutex x509_crt_parse_path() when pthreads is used
2013-11-28 16:11:54 +00:00
goto cleanup;
Fixed file descriptor leak in x509parse_crtpath()
2013-09-09 15:26:14 +00:00
}
x509parse_crtpath() is now reentrant and uses more portable stat() Moved from readdir() to readdir_r() and use stat instead of the less portable d_type from struct dirent. (cherry picked from commit cbfcaa9206be586f6bf8ac26586cd63a6c8c8e15)
2013-06-24 17:22:42 +00:00
if( !S_ISREG( sb.st_mode ) )
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
continue;
x509parse_crtpath() is now reentrant and uses more portable stat() Moved from readdir() to readdir_r() and use stat instead of the less portable d_type from struct dirent. (cherry picked from commit cbfcaa9206be586f6bf8ac26586cd63a6c8c8e15)
2013-06-24 17:22:42 +00:00
// Ignore parse errors
//
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
t_ret = mbedtls_x509_crt_parse_file( chain, entry_name );
- Added X509 CA Path support
2012-06-04 12:46:42 +00:00
if( t_ret < 0 )
x509parse_crtpath() is now reentrant and uses more portable stat() Moved from readdir() to readdir_r() and use stat instead of the less portable d_type from struct dirent. (cherry picked from commit cbfcaa9206be586f6bf8ac26586cd63a6c8c8e15)
2013-06-24 17:22:42 +00:00
ret++;
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
else
ret += t_ret;
}
Mutex x509_crt_parse_path() when pthreads is used
2013-11-28 16:11:54 +00:00
cleanup:
Allow the entry_name size to be set in config.h Allow the size of the entry_name character array in x509_crt.c to be configurable through a macro in config.h. entry_name holds a path/filename string. The macro introduced in MBEDTLS_X509_MAX_FILE_PATH_LEN.
2016-09-02 13:06:04 +00:00
closedir( dir );
Wrong preproccessor condition fix Fix for issue #696 Change #if defined(MBEDTLS_THREADING_PTHREAD) to #if defined(MBEDTLS_THREADING_C)
2017-01-09 17:27:59 +00:00
#if defined(MBEDTLS_THREADING_C)
Allow use of global mutexes with threading_alt
2015-05-27 18:07:18 +00:00
if( mbedtls_mutex_unlock( &mbedtls_threading_readdir_mutex ) != 0 )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = MBEDTLS_ERR_THREADING_MUTEX_ERROR;
Wrong preproccessor condition fix Fix for issue #696 Change #if defined(MBEDTLS_THREADING_PTHREAD) to #if defined(MBEDTLS_THREADING_C)
2017-01-09 17:27:59 +00:00
#endif /* MBEDTLS_THREADING_C */
Mutex x509_crt_parse_path() when pthreads is used
2013-11-28 16:11:54 +00:00
Introduced POLARSSL_HAVE_READDIR_R for systems without it
2013-10-14 13:51:50 +00:00
#endif /* _WIN32 */
Get rid of pk_wrap_rsa()
2013-08-14 11:39:57 +00:00
return( ret );
Fix some ifdef's in x509parse While at it: - move _rsa variants systematically after generic functions - unsplit x509parse_key_pkcs8_encrypted_der() (reverts a5d9974)
2013-07-11 14:17:23 +00:00
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#endif /* MBEDTLS_FS_IO */
Fix some ifdef's in x509parse While at it: - move _rsa variants systematically after generic functions - unsplit x509parse_key_pkcs8_encrypted_der() (reverts a5d9974)
2013-07-11 14:17:23 +00:00
Move signature-info extraction out of MBEDTLS_X509_REMOVE_INFO During rebase, the definition of ::mbedtls_x509_crt_sig_info as well as x509_crt_free_sig_info() and x509_crt_get_sig_info() were accidentally guarded by !MBEDTLS_X509_REMOVE_INFO. This commit moves their definition outside of that guard.
2019-06-25 08:42:57 +00:00
typedef struct mbedtls_x509_crt_sig_info
{
mbedtls_md_type_t sig_md;
mbedtls_pk_type_t sig_pk;
void *sig_opts;
uint8_t crt_hash[MBEDTLS_MD_MAX_SIZE];
size_t crt_hash_len;
mbedtls_x509_buf_raw sig;
mbedtls_x509_buf_raw issuer_raw;
} mbedtls_x509_crt_sig_info;
static void x509_crt_free_sig_info( mbedtls_x509_crt_sig_info *info )
{
#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
mbedtls_free( info->sig_opts );
#else
((void) info);
#endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
}
static int x509_crt_get_sig_info( mbedtls_x509_crt_frame const *frame,
mbedtls_x509_crt_sig_info *info )
{
const mbedtls_md_info_t *md_info;
md_info = mbedtls_md_info_from_type( frame->sig_md );
if( mbedtls_md( md_info, frame->tbs.p, frame->tbs.len,
info->crt_hash ) != 0 )
{
/* Note: this can't happen except after an internal error */
return( -1 );
}
info->crt_hash_len = mbedtls_md_get_size( md_info );
/* Make sure that this function leaves the target structure
* ready to be freed, regardless of success of failure. */
info->sig_opts = NULL;
#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
{
int ret;
unsigned char *alg_start = frame->sig_alg.p;
unsigned char *alg_end = alg_start + frame->sig_alg.len;
/* Get signature options -- currently only
* necessary for RSASSA-PSS. */
ret = mbedtls_x509_get_sig_alg_raw( &alg_start, alg_end, &info->sig_md,
&info->sig_pk, &info->sig_opts );
if( ret != 0 )
{
/* Note: this can't happen except after an internal error */
return( -1 );
}
}
#else /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
info->sig_md = frame->sig_md;
info->sig_pk = frame->sig_pk;
#endif /* !MBEDTLS_X509_RSASSA_PSS_SUPPORT */
info->issuer_raw = frame->issuer_raw;
info->sig = frame->sig;
return( 0 );
}
Rename MBEDTLS_X509_INFO to !MBEDTLS_X509_REMOVE_INFO
2019-06-10 14:08:43 +00:00
#if !defined(MBEDTLS_X509_REMOVE_INFO)
Print subject alt name in x509_crt_info()
2014-04-01 11:43:28 +00:00
static int x509_info_subject_alt_name( char **buf, size_t *size,
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
const mbedtls_x509_sequence *subject_alt_name )
Print subject alt name in x509_crt_info()
2014-04-01 11:43:28 +00:00
{
size_t i;
size_t n = *size;
char *p = *buf;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
const mbedtls_x509_sequence *cur = subject_alt_name;
x509_crt_info() list output cosmectics
2014-04-01 16:00:07 +00:00
const char *sep = "";
size_t sep_len = 0;
Print subject alt name in x509_crt_info()
2014-04-01 11:43:28 +00:00
while( cur != NULL )
{
x509_crt_info() list output cosmectics
2014-04-01 16:00:07 +00:00
if( cur->buf.len + sep_len >= n )
Print subject alt name in x509_crt_info()
2014-04-01 11:43:28 +00:00
{
*p = '\0';
Rationalize snprintf() usage in X.509 modules
2015-06-22 09:12:02 +00:00
return( MBEDTLS_ERR_X509_BUFFER_TOO_SMALL );
Print subject alt name in x509_crt_info()
2014-04-01 11:43:28 +00:00
}
x509_crt_info() list output cosmectics
2014-04-01 16:00:07 +00:00
n -= cur->buf.len + sep_len;
for( i = 0; i < sep_len; i++ )
*p++ = sep[i];
Print subject alt name in x509_crt_info()
2014-04-01 11:43:28 +00:00
for( i = 0; i < cur->buf.len; i++ )
*p++ = cur->buf.p[i];
x509_crt_info() list output cosmectics
2014-04-01 16:00:07 +00:00
sep = ", ";
sep_len = 2;
Print subject alt name in x509_crt_info()
2014-04-01 11:43:28 +00:00
cur = cur->next;
}
*p = '\0';
*size = n;
*buf = p;
return( 0 );
}
More compact code using macros
2014-04-01 16:12:24 +00:00
#define PRINT_ITEM(i) \
{ \
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_snprintf( p, n, "%s" i, sep ); \
Rationalize snprintf() usage in X.509 modules
2015-06-22 09:12:02 +00:00
MBEDTLS_X509_SAFE_SNPRINTF; \
More compact code using macros
2014-04-01 16:12:24 +00:00
sep = ", "; \
}
#define CERT_TYPE(type,name) \
Improve macro hygiene This commit improves hygiene and formatting of macro definitions throughout the library. Specifically: - It adds brackets around parameters to avoid unintended interpretation of arguments, e.g. due to operator precedence. - It adds uses of the `do { ... } while( 0 )` idiom for macros that can be used as commands.
2018-10-15 11:01:35 +00:00
if( ns_cert_type & (type) ) \
More compact code using macros
2014-04-01 16:12:24 +00:00
PRINT_ITEM( name );
Print NS Cert Type in x509_crt_info()
2014-04-01 11:01:11 +00:00
static int x509_info_cert_type( char **buf, size_t *size,
unsigned char ns_cert_type )
{
int ret;
size_t n = *size;
char *p = *buf;
x509_crt_info() list output cosmectics
2014-04-01 16:00:07 +00:00
const char *sep = "";
Print NS Cert Type in x509_crt_info()
2014-04-01 11:01:11 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_CLIENT, "SSL Client" );
Fix some X509 macro names For some reason, during the great renaming, some names that should have been prefixed with MBEDTLS_X509_ have only been prefixed with MBEDTLS_
2015-04-20 11:19:02 +00:00
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_SERVER, "SSL Server" );
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_EMAIL, "Email" );
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_OBJECT_SIGNING, "Object Signing" );
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_RESERVED, "Reserved" );
Fix some X509 macro names For some reason, during the great renaming, some names that should have been prefixed with MBEDTLS_X509_ have only been prefixed with MBEDTLS_
2015-04-20 11:19:02 +00:00
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_CA, "SSL CA" );
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_EMAIL_CA, "Email CA" );
CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_OBJECT_SIGNING_CA, "Object Signing CA" );
Print NS Cert Type in x509_crt_info()
2014-04-01 11:01:11 +00:00
*size = n;
*buf = p;
return( 0 );
}
More compact code using macros
2014-04-01 16:12:24 +00:00
#define KEY_USAGE(code,name) \
Improve macro hygiene This commit improves hygiene and formatting of macro definitions throughout the library. Specifically: - It adds brackets around parameters to avoid unintended interpretation of arguments, e.g. due to operator precedence. - It adds uses of the `do { ... } while( 0 )` idiom for macros that can be used as commands.
2018-10-15 11:01:35 +00:00
if( key_usage & (code) ) \
More compact code using macros
2014-04-01 16:12:24 +00:00
PRINT_ITEM( name );
Print key_usage in x509_crt_info()
2014-04-01 12:12:11 +00:00
static int x509_info_key_usage( char **buf, size_t *size,
Add parsing/printing for new X.509 keyUsage flags
2015-06-23 08:14:36 +00:00
unsigned int key_usage )
Print key_usage in x509_crt_info()
2014-04-01 12:12:11 +00:00
{
int ret;
size_t n = *size;
char *p = *buf;
x509_crt_info() list output cosmectics
2014-04-01 16:00:07 +00:00
const char *sep = "";
Print key_usage in x509_crt_info()
2014-04-01 12:12:11 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
KEY_USAGE( MBEDTLS_X509_KU_DIGITAL_SIGNATURE, "Digital Signature" );
KEY_USAGE( MBEDTLS_X509_KU_NON_REPUDIATION, "Non Repudiation" );
Fix some X509 macro names For some reason, during the great renaming, some names that should have been prefixed with MBEDTLS_X509_ have only been prefixed with MBEDTLS_
2015-04-20 11:19:02 +00:00
KEY_USAGE( MBEDTLS_X509_KU_KEY_ENCIPHERMENT, "Key Encipherment" );
KEY_USAGE( MBEDTLS_X509_KU_DATA_ENCIPHERMENT, "Data Encipherment" );
KEY_USAGE( MBEDTLS_X509_KU_KEY_AGREEMENT, "Key Agreement" );
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
KEY_USAGE( MBEDTLS_X509_KU_KEY_CERT_SIGN, "Key Cert Sign" );
KEY_USAGE( MBEDTLS_X509_KU_CRL_SIGN, "CRL Sign" );
Add parsing/printing for new X.509 keyUsage flags
2015-06-23 08:14:36 +00:00
KEY_USAGE( MBEDTLS_X509_KU_ENCIPHER_ONLY, "Encipher Only" );
KEY_USAGE( MBEDTLS_X509_KU_DECIPHER_ONLY, "Decipher Only" );
Print key_usage in x509_crt_info()
2014-04-01 12:12:11 +00:00
*size = n;
*buf = p;
return( 0 );
}
Print extended key usage in x509_crt_info()
2014-04-01 15:32:44 +00:00
static int x509_info_ext_key_usage( char **buf, size_t *size,
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
const mbedtls_x509_sequence *extended_key_usage )
Print extended key usage in x509_crt_info()
2014-04-01 15:32:44 +00:00
{
int ret;
const char *desc;
size_t n = *size;
char *p = *buf;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
const mbedtls_x509_sequence *cur = extended_key_usage;
x509_crt_info() list output cosmectics
2014-04-01 16:00:07 +00:00
const char *sep = "";
Print extended key usage in x509_crt_info()
2014-04-01 15:32:44 +00:00
while( cur != NULL )
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( mbedtls_oid_get_extended_key_usage( &cur->buf, &desc ) != 0 )
Print extended key usage in x509_crt_info()
2014-04-01 15:32:44 +00:00
desc = "???";
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_snprintf( p, n, "%s%s", sep, desc );
Rationalize snprintf() usage in X.509 modules
2015-06-22 09:12:02 +00:00
MBEDTLS_X509_SAFE_SNPRINTF;
Print extended key usage in x509_crt_info()
2014-04-01 15:32:44 +00:00
x509_crt_info() list output cosmectics
2014-04-01 16:00:07 +00:00
sep = ", ";
Print extended key usage in x509_crt_info()
2014-04-01 15:32:44 +00:00
cur = cur->next;
}
*size = n;
*buf = p;
return( 0 );
}
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
/*
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
* Return an informational string about the certificate.
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*/
Start printing extensions in x509_crt_info()
2014-04-01 10:19:09 +00:00
#define BEFORE_COLON 18
#define BC "18"
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
int mbedtls_x509_crt_info( char *buf, size_t size, const char *prefix,
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
const mbedtls_x509_crt *crt )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
{
- Major type rewrite of int to size_t for most variables and arguments used for buffer lengths and loops
2011-04-24 08:57:21 +00:00
int ret;
size_t n;
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
char *p;
Add name and get_size() members in PK
2013-08-12 17:45:32 +00:00
char key_size_str[BEFORE_COLON];
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
mbedtls_x509_crt_frame frame;
mbedtls_pk_context pk;
Make use of CRT acquire/release in mbedtls_x509_crt_info() This commit adapts `mbedtls_x509_crt_info()` to no longer access structure fields from `mbedtls_x509_crt` directly, but to instead query for a `mbedtls_x509_crt_frame` and `mbedtls_pk_context` and use these to extract the required CRT information.
2019-02-24 16:47:57 +00:00
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
mbedtls_x509_name *issuer = NULL, *subject = NULL;
mbedtls_x509_sequence *ext_key_usage = NULL, *subject_alt_names = NULL;
Make use of CRT acquire/release in mbedtls_x509_crt_info() This commit adapts `mbedtls_x509_crt_info()` to no longer access structure fields from `mbedtls_x509_crt` directly, but to instead query for a `mbedtls_x509_crt_frame` and `mbedtls_pk_context` and use these to extract the required CRT information.
2019-02-24 16:47:57 +00:00
mbedtls_x509_crt_sig_info sig_info;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
p = buf;
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
n = size;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Make use of CRT acquire/release in mbedtls_x509_crt_info() This commit adapts `mbedtls_x509_crt_info()` to no longer access structure fields from `mbedtls_x509_crt` directly, but to instead query for a `mbedtls_x509_crt_frame` and `mbedtls_pk_context` and use these to extract the required CRT information.
2019-02-24 16:47:57 +00:00
memset( &sig_info, 0, sizeof( mbedtls_x509_crt_sig_info ) );
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
mbedtls_pk_init( &pk );
if( NULL == crt )
Address user reported coverity issues.
2016-05-31 13:03:54 +00:00
{
ret = mbedtls_snprintf( p, n, "\nCertificate is uninitialised!\n" );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Address user reported coverity issues.
2016-05-31 13:03:54 +00:00
return( (int) ( size - n ) );
}
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
ret = mbedtls_x509_crt_get_frame( crt, &frame );
Make use of CRT acquire/release in mbedtls_x509_crt_info() This commit adapts `mbedtls_x509_crt_info()` to no longer access structure fields from `mbedtls_x509_crt` directly, but to instead query for a `mbedtls_x509_crt_frame` and `mbedtls_pk_context` and use these to extract the required CRT information.
2019-02-24 16:47:57 +00:00
if( ret != 0 )
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
{
ret = MBEDTLS_ERR_X509_FATAL_ERROR;
goto cleanup;
}
Make use of CRT acquire/release in mbedtls_x509_crt_info() This commit adapts `mbedtls_x509_crt_info()` to no longer access structure fields from `mbedtls_x509_crt` directly, but to instead query for a `mbedtls_x509_crt_frame` and `mbedtls_pk_context` and use these to extract the required CRT information.
2019-02-24 16:47:57 +00:00
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
ret = mbedtls_x509_crt_get_subject( crt, &subject );
Make use of CRT acquire/release in mbedtls_x509_crt_info() This commit adapts `mbedtls_x509_crt_info()` to no longer access structure fields from `mbedtls_x509_crt` directly, but to instead query for a `mbedtls_x509_crt_frame` and `mbedtls_pk_context` and use these to extract the required CRT information.
2019-02-24 16:47:57 +00:00
if( ret != 0 )
{
ret = MBEDTLS_ERR_X509_FATAL_ERROR;
goto cleanup;
}
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
ret = mbedtls_x509_crt_get_issuer( crt, &issuer );
Make use of CRT acquire/release in mbedtls_x509_crt_info() This commit adapts `mbedtls_x509_crt_info()` to no longer access structure fields from `mbedtls_x509_crt` directly, but to instead query for a `mbedtls_x509_crt_frame` and `mbedtls_pk_context` and use these to extract the required CRT information.
2019-02-24 16:47:57 +00:00
if( ret != 0 )
{
ret = MBEDTLS_ERR_X509_FATAL_ERROR;
goto cleanup;
}
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
ret = mbedtls_x509_crt_get_subject_alt_names( crt, &subject_alt_names );
Make use of CRT acquire/release in mbedtls_x509_crt_info() This commit adapts `mbedtls_x509_crt_info()` to no longer access structure fields from `mbedtls_x509_crt` directly, but to instead query for a `mbedtls_x509_crt_frame` and `mbedtls_pk_context` and use these to extract the required CRT information.
2019-02-24 16:47:57 +00:00
if( ret != 0 )
{
ret = MBEDTLS_ERR_X509_FATAL_ERROR;
goto cleanup;
}
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
ret = mbedtls_x509_crt_get_ext_key_usage( crt, &ext_key_usage );
Make use of CRT acquire/release in mbedtls_x509_crt_info() This commit adapts `mbedtls_x509_crt_info()` to no longer access structure fields from `mbedtls_x509_crt` directly, but to instead query for a `mbedtls_x509_crt_frame` and `mbedtls_pk_context` and use these to extract the required CRT information.
2019-02-24 16:47:57 +00:00
if( ret != 0 )
{
ret = MBEDTLS_ERR_X509_FATAL_ERROR;
goto cleanup;
}
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
ret = mbedtls_x509_crt_get_pk( crt, &pk );
Make use of CRT acquire/release in mbedtls_x509_crt_info() This commit adapts `mbedtls_x509_crt_info()` to no longer access structure fields from `mbedtls_x509_crt` directly, but to instead query for a `mbedtls_x509_crt_frame` and `mbedtls_pk_context` and use these to extract the required CRT information.
2019-02-24 16:47:57 +00:00
if( ret != 0 )
{
ret = MBEDTLS_ERR_X509_FATAL_ERROR;
goto cleanup;
}
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
ret = x509_crt_get_sig_info( &frame, &sig_info );
Make use of CRT acquire/release in mbedtls_x509_crt_info() This commit adapts `mbedtls_x509_crt_info()` to no longer access structure fields from `mbedtls_x509_crt` directly, but to instead query for a `mbedtls_x509_crt_frame` and `mbedtls_pk_context` and use these to extract the required CRT information.
2019-02-24 16:47:57 +00:00
if( ret != 0 )
{
ret = MBEDTLS_ERR_X509_FATAL_ERROR;
goto cleanup;
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_snprintf( p, n, "%scert. version : %d\n",
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
prefix, frame.version );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Make use of CRT acquire/release in mbedtls_x509_crt_info() This commit adapts `mbedtls_x509_crt_info()` to no longer access structure fields from `mbedtls_x509_crt` directly, but to instead query for a `mbedtls_x509_crt_frame` and `mbedtls_pk_context` and use these to extract the required CRT information.
2019-02-24 16:47:57 +00:00
{
mbedtls_x509_buf serial;
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
serial.p = frame.serial.p;
serial.len = frame.serial.len;
Make use of CRT acquire/release in mbedtls_x509_crt_info() This commit adapts `mbedtls_x509_crt_info()` to no longer access structure fields from `mbedtls_x509_crt` directly, but to instead query for a `mbedtls_x509_crt_frame` and `mbedtls_pk_context` and use these to extract the required CRT information.
2019-02-24 16:47:57 +00:00
ret = mbedtls_snprintf( p, n, "%sserial number : ",
prefix );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Make use of CRT acquire/release in mbedtls_x509_crt_info() This commit adapts `mbedtls_x509_crt_info()` to no longer access structure fields from `mbedtls_x509_crt` directly, but to instead query for a `mbedtls_x509_crt_frame` and `mbedtls_pk_context` and use these to extract the required CRT information.
2019-02-24 16:47:57 +00:00
ret = mbedtls_x509_serial_gets( p, n, &serial );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Make use of CRT acquire/release in mbedtls_x509_crt_info() This commit adapts `mbedtls_x509_crt_info()` to no longer access structure fields from `mbedtls_x509_crt` directly, but to instead query for a `mbedtls_x509_crt_frame` and `mbedtls_pk_context` and use these to extract the required CRT information.
2019-02-24 16:47:57 +00:00
}
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_snprintf( p, n, "\n%sissuer name : ", prefix );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
ret = mbedtls_x509_dn_gets( p, n, issuer );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_snprintf( p, n, "\n%ssubject name : ", prefix );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
ret = mbedtls_x509_dn_gets( p, n, subject );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_snprintf( p, n, "\n%sissued on : " \
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
"%04d-%02d-%02d %02d:%02d:%02d", prefix,
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
frame.valid_from.year, frame.valid_from.mon,
frame.valid_from.day, frame.valid_from.hour,
frame.valid_from.min, frame.valid_from.sec );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_snprintf( p, n, "\n%sexpires on : " \
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
"%04d-%02d-%02d %02d:%02d:%02d", prefix,
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
frame.valid_to.year, frame.valid_to.mon,
frame.valid_to.day, frame.valid_to.hour,
frame.valid_to.min, frame.valid_to.sec );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_snprintf( p, n, "\n%ssigned using : ", prefix );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Remove `sig_oid` parameter from mbedtls_x509_sig_alg_gets() The function `mbedtls_x509_sig_alg_gets()` previously needed the raw ASN.1 OID string even though it is implicit in the PK and MD parameters. This commit modifies `mbedtls_x509_sig_alg_gets()` to infer the OID and remove it from the parameters. This will be needed for the new X.509 CRT structure which will likely not store the signature OID. Care has to be taken to handle the case of RSASSA-PSS correctly, where the hash algorithm in the OID list is set to MBEDTLS_MD_NONE because it's only determined by the algorithm parameters.
2019-02-21 17:13:46 +00:00
ret = mbedtls_x509_sig_alg_gets( p, n, sig_info.sig_pk,
sig_info.sig_md, sig_info.sig_opts );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Start printing extensions in x509_crt_info()
2014-04-01 10:19:09 +00:00
/* Key size */
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ( ret = mbedtls_x509_key_size_helper( key_size_str, BEFORE_COLON,
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
mbedtls_pk_get_name( &pk ) ) ) != 0 )
Add name and get_size() members in PK
2013-08-12 17:45:32 +00:00
{
return( ret );
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_snprintf( p, n, "\n%s%-" BC "s: %d bits", prefix, key_size_str,
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
(int) mbedtls_pk_get_bitlen( &pk ) );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Start printing extensions in x509_crt_info()
2014-04-01 10:19:09 +00:00
/*
* Optional extensions
*/
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
if( frame.ext_types & MBEDTLS_X509_EXT_BASIC_CONSTRAINTS )
Start printing extensions in x509_crt_info()
2014-04-01 10:19:09 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_snprintf( p, n, "\n%sbasic constraints : CA=%s", prefix,
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
frame.ca_istrue ? "true" : "false" );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Start printing extensions in x509_crt_info()
2014-04-01 10:19:09 +00:00
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
if( frame.max_pathlen > 0 )
Start printing extensions in x509_crt_info()
2014-04-01 10:19:09 +00:00
{
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
ret = mbedtls_snprintf( p, n, ", max_pathlen=%d", frame.max_pathlen - 1 );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Start printing extensions in x509_crt_info()
2014-04-01 10:19:09 +00:00
}
}
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
if( frame.ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME )
Start printing extensions in x509_crt_info()
2014-04-01 10:19:09 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_snprintf( p, n, "\n%ssubject alt name : ", prefix );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Print subject alt name in x509_crt_info()
2014-04-01 11:43:28 +00:00
if( ( ret = x509_info_subject_alt_name( &p, &n,
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
subject_alt_names ) ) != 0 )
Print subject alt name in x509_crt_info()
2014-04-01 11:43:28 +00:00
return( ret );
Start printing extensions in x509_crt_info()
2014-04-01 10:19:09 +00:00
}
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
if( frame.ext_types & MBEDTLS_X509_EXT_NS_CERT_TYPE )
Start printing extensions in x509_crt_info()
2014-04-01 10:19:09 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_snprintf( p, n, "\n%scert. type : ", prefix );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Print NS Cert Type in x509_crt_info()
2014-04-01 11:01:11 +00:00
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
if( ( ret = x509_info_cert_type( &p, &n, frame.ns_cert_type ) ) != 0 )
Print NS Cert Type in x509_crt_info()
2014-04-01 11:01:11 +00:00
return( ret );
Start printing extensions in x509_crt_info()
2014-04-01 10:19:09 +00:00
}
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
if( frame.ext_types & MBEDTLS_X509_EXT_KEY_USAGE )
Start printing extensions in x509_crt_info()
2014-04-01 10:19:09 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_snprintf( p, n, "\n%skey usage : ", prefix );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Print key_usage in x509_crt_info()
2014-04-01 12:12:11 +00:00
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
if( ( ret = x509_info_key_usage( &p, &n, frame.key_usage ) ) != 0 )
Print key_usage in x509_crt_info()
2014-04-01 12:12:11 +00:00
return( ret );
Start printing extensions in x509_crt_info()
2014-04-01 10:19:09 +00:00
}
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
if( frame.ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE )
Start printing extensions in x509_crt_info()
2014-04-01 10:19:09 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_snprintf( p, n, "\n%sext key usage : ", prefix );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Print extended key usage in x509_crt_info()
2014-04-01 15:32:44 +00:00
if( ( ret = x509_info_ext_key_usage( &p, &n,
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
ext_key_usage ) ) != 0 )
Print extended key usage in x509_crt_info()
2014-04-01 15:32:44 +00:00
return( ret );
Start printing extensions in x509_crt_info()
2014-04-01 10:19:09 +00:00
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
ret = mbedtls_snprintf( p, n, "\n" );
Rename MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR to _WITH_CLEANUP
2019-05-13 10:58:47 +00:00
MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Start printing extensions in x509_crt_info()
2014-04-01 10:19:09 +00:00
Make use of CRT acquire/release in mbedtls_x509_crt_info() This commit adapts `mbedtls_x509_crt_info()` to no longer access structure fields from `mbedtls_x509_crt` directly, but to instead query for a `mbedtls_x509_crt_frame` and `mbedtls_pk_context` and use these to extract the required CRT information.
2019-02-24 16:47:57 +00:00
ret = (int) ( size - n );
cleanup:
x509_crt_free_sig_info( &sig_info );
Modify mbedtls_x509_crt_info() to use getter API
2019-02-27 17:38:40 +00:00
mbedtls_pk_free( &pk );
mbedtls_x509_name_free( issuer );
mbedtls_x509_name_free( subject );
mbedtls_x509_sequence_free( ext_key_usage );
mbedtls_x509_sequence_free( subject_alt_names );
Make use of CRT acquire/release in mbedtls_x509_crt_info() This commit adapts `mbedtls_x509_crt_info()` to no longer access structure fields from `mbedtls_x509_crt` directly, but to instead query for a `mbedtls_x509_crt_frame` and `mbedtls_pk_context` and use these to extract the required CRT information.
2019-02-24 16:47:57 +00:00
return( ret );
- Added prelimenary CRL parsing and info support
2009-05-02 15:13:40 +00:00
}
manually merge 39a183a add x509_crt_verify_info()
2015-04-20 09:38:13 +00:00
struct x509_crt_verify_string {
int code;
const char *string;
};
static const struct x509_crt_verify_string x509_crt_verify_strings[] = {
Fix some X509 macro names For some reason, during the great renaming, some names that should have been prefixed with MBEDTLS_X509_ have only been prefixed with MBEDTLS_
2015-04-20 11:19:02 +00:00
{ MBEDTLS_X509_BADCERT_EXPIRED, "The certificate validity has expired" },
manually merge 39a183a add x509_crt_verify_info()
2015-04-20 09:38:13 +00:00
{ MBEDTLS_X509_BADCERT_REVOKED, "The certificate has been revoked (is on a CRL)" },
{ MBEDTLS_X509_BADCERT_CN_MISMATCH, "The certificate Common Name (CN) does not match with the expected CN" },
{ MBEDTLS_X509_BADCERT_NOT_TRUSTED, "The certificate is not correctly signed by the trusted CA" },
{ MBEDTLS_X509_BADCRL_NOT_TRUSTED, "The CRL is not correctly signed by the trusted CA" },
{ MBEDTLS_X509_BADCRL_EXPIRED, "The CRL is expired" },
Fix some X509 macro names For some reason, during the great renaming, some names that should have been prefixed with MBEDTLS_X509_ have only been prefixed with MBEDTLS_
2015-04-20 11:19:02 +00:00
{ MBEDTLS_X509_BADCERT_MISSING, "Certificate was missing" },
{ MBEDTLS_X509_BADCERT_SKIP_VERIFY, "Certificate verification was skipped" },
{ MBEDTLS_X509_BADCERT_OTHER, "Other reason (can be used by verify callback)" },
manually merge 39a183a add x509_crt_verify_info()
2015-04-20 09:38:13 +00:00
{ MBEDTLS_X509_BADCERT_FUTURE, "The certificate validity starts in the future" },
Fix some X509 macro names For some reason, during the great renaming, some names that should have been prefixed with MBEDTLS_X509_ have only been prefixed with MBEDTLS_
2015-04-20 11:19:02 +00:00
{ MBEDTLS_X509_BADCRL_FUTURE, "The CRL is from the future" },
{ MBEDTLS_X509_BADCERT_KEY_USAGE, "Usage does not match the keyUsage extension" },
{ MBEDTLS_X509_BADCERT_EXT_KEY_USAGE, "Usage does not match the extendedKeyUsage extension" },
{ MBEDTLS_X509_BADCERT_NS_CERT_TYPE, "Usage does not match the nsCertType extension" },
Create cert profile API (unimplemented yet)
2015-06-15 08:39:46 +00:00
{ MBEDTLS_X509_BADCERT_BAD_MD, "The certificate is signed with an unacceptable hash." },
{ MBEDTLS_X509_BADCERT_BAD_PK, "The certificate is signed with an unacceptable PK alg (eg RSA vs ECDSA)." },
{ MBEDTLS_X509_BADCERT_BAD_KEY, "The certificate is signed with an unacceptable key (eg bad curve, RSA too short)." },
{ MBEDTLS_X509_BADCRL_BAD_MD, "The CRL is signed with an unacceptable hash." },
{ MBEDTLS_X509_BADCRL_BAD_PK, "The CRL is signed with an unacceptable PK alg (eg RSA vs ECDSA)." },
{ MBEDTLS_X509_BADCRL_BAD_KEY, "The CRL is signed with an unacceptable key (eg bad curve, RSA too short)." },
manually merge 39a183a add x509_crt_verify_info()
2015-04-20 09:38:13 +00:00
{ 0, NULL }
};
int mbedtls_x509_crt_verify_info( char *buf, size_t size, const char *prefix,
Change X.509 verify flags to uint32_t
2015-05-11 17:54:43 +00:00
uint32_t flags )
manually merge 39a183a add x509_crt_verify_info()
2015-04-20 09:38:13 +00:00
{
int ret;
const struct x509_crt_verify_string *cur;
char *p = buf;
size_t n = size;
for( cur = x509_crt_verify_strings; cur->string != NULL ; cur++ )
{
if( ( flags & cur->code ) == 0 )
continue;
ret = mbedtls_snprintf( p, n, "%s%s\n", prefix, cur->string );
Rationalize snprintf() usage in X.509 modules
2015-06-22 09:12:02 +00:00
MBEDTLS_X509_SAFE_SNPRINTF;
manually merge 39a183a add x509_crt_verify_info()
2015-04-20 09:38:13 +00:00
flags ^= cur->code;
}
if( flags != 0 )
{
ret = mbedtls_snprintf( p, n, "%sUnknown reason "
"(this should not happen)\n", prefix );
Rationalize snprintf() usage in X.509 modules
2015-06-22 09:12:02 +00:00
MBEDTLS_X509_SAFE_SNPRINTF;
manually merge 39a183a add x509_crt_verify_info()
2015-04-20 09:38:13 +00:00
}
return( (int) ( size - n ) );
}
Rename MBEDTLS_X509_INFO to !MBEDTLS_X509_REMOVE_INFO
2019-06-10 14:08:43 +00:00
#endif /* !MBEDTLS_X509_REMOVE_INFO */
manually merge 39a183a add x509_crt_verify_info()
2015-04-20 09:38:13 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
Make use of CRT acquire/release in mbedtls_x509_crt_check_key_usage
2019-02-25 13:55:33 +00:00
static int x509_crt_check_key_usage_frame( const mbedtls_x509_crt_frame *crt,
unsigned int usage )
Add x509_crt_check_key_usage()
2014-04-09 07:50:03 +00:00
{
Adapt check_key_usage to new weird bits
2015-06-23 08:48:44 +00:00
unsigned int usage_must, usage_may;
unsigned int may_mask = MBEDTLS_X509_KU_ENCIPHER_ONLY
| MBEDTLS_X509_KU_DECIPHER_ONLY;
if( ( crt->ext_types & MBEDTLS_X509_EXT_KEY_USAGE ) == 0 )
return( 0 );
usage_must = usage & ~may_mask;
if( ( ( crt->key_usage & ~may_mask ) & usage_must ) != usage_must )
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
usage_may = usage & may_mask;
if( ( ( crt->key_usage & may_mask ) | usage_may ) != usage_may )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Add x509_crt_check_key_usage()
2014-04-09 07:50:03 +00:00
return( 0 );
}
Make use of CRT acquire/release in mbedtls_x509_crt_check_key_usage
2019-02-25 13:55:33 +00:00
int mbedtls_x509_crt_check_key_usage( const mbedtls_x509_crt *crt,
unsigned int usage )
{
int ret;
Don't allow change of CRT frame returned by x509_crt_frame_acquire()
2019-05-20 15:26:34 +00:00
mbedtls_x509_crt_frame const *frame;
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
Make use of CRT acquire/release in mbedtls_x509_crt_check_key_usage
2019-02-25 13:55:33 +00:00
if( ret != 0 )
return( MBEDTLS_ERR_X509_FATAL_ERROR );
ret = x509_crt_check_key_usage_frame( frame, usage );
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_frame_release( crt );
Make use of CRT acquire/release in mbedtls_x509_crt_check_key_usage
2019-02-25 13:55:33 +00:00
return( ret );
}
Add x509_crt_check_key_usage()
2014-04-09 07:50:03 +00:00
#endif
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE)
Implement ExtKeyUsage traversal via ASN.1 SEQUENCE OF traversal This commit re-implements the `ExtendedKeyUsage` traversal routine in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-21 21:10:51 +00:00
typedef struct
{
const char *oid;
size_t oid_len;
} x509_crt_check_ext_key_usage_cb_ctx_t;
static int x509_crt_check_ext_key_usage_cb( void *ctx,
int tag,
unsigned char *data,
size_t data_len )
{
x509_crt_check_ext_key_usage_cb_ctx_t *cb_ctx =
(x509_crt_check_ext_key_usage_cb_ctx_t *) ctx;
((void) tag);
if( MBEDTLS_OID_CMP_RAW( MBEDTLS_OID_ANY_EXTENDED_KEY_USAGE,
data, data_len ) == 0 )
{
return( 1 );
}
if( data_len == cb_ctx->oid_len && memcmp( data, cb_ctx->oid,
data_len ) == 0 )
{
return( 1 );
}
return( 0 );
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
int mbedtls_x509_crt_check_extended_key_usage( const mbedtls_x509_crt *crt,
Check for extended key usage by traversing raw extension data This commit re-implements `mbedtls_x509_crt_check_extended_key_usage()` to not use the dynamically allocated linked list presentation of the `ExtendedKeyUsage` but to search for the required usage by traversing the raw ASN.1 data.
2019-02-21 14:28:12 +00:00
const char *usage_oid,
size_t usage_len )
Add x509_crt_check_extended_key_usage()
2014-04-10 15:53:56 +00:00
{
Check for extended key usage by traversing raw extension data This commit re-implements `mbedtls_x509_crt_check_extended_key_usage()` to not use the dynamically allocated linked list presentation of the `ExtendedKeyUsage` but to search for the required usage by traversing the raw ASN.1 data.
2019-02-21 14:28:12 +00:00
int ret;
Don't allow change of CRT frame returned by x509_crt_frame_acquire()
2019-05-20 15:26:34 +00:00
mbedtls_x509_crt_frame const *frame;
Check for extended key usage by traversing raw extension data This commit re-implements `mbedtls_x509_crt_check_extended_key_usage()` to not use the dynamically allocated linked list presentation of the `ExtendedKeyUsage` but to search for the required usage by traversing the raw ASN.1 data.
2019-02-21 14:28:12 +00:00
unsigned ext_types;
unsigned char *p, *end;
Implement ExtKeyUsage traversal via ASN.1 SEQUENCE OF traversal This commit re-implements the `ExtendedKeyUsage` traversal routine in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-21 21:10:51 +00:00
x509_crt_check_ext_key_usage_cb_ctx_t cb_ctx = { usage_oid, usage_len };
Add x509_crt_check_extended_key_usage()
2014-04-10 15:53:56 +00:00
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
Make use of CRT acquire/release in ExtKeyUsage checking
2019-02-25 18:11:42 +00:00
if( ret != 0 )
return( MBEDTLS_ERR_X509_FATAL_ERROR );
Check for extended key usage by traversing raw extension data This commit re-implements `mbedtls_x509_crt_check_extended_key_usage()` to not use the dynamically allocated linked list presentation of the `ExtendedKeyUsage` but to search for the required usage by traversing the raw ASN.1 data.
2019-02-21 14:28:12 +00:00
Make use of CRT acquire/release in ExtKeyUsage checking
2019-02-25 18:11:42 +00:00
/* Extension is not mandatory, absent means no restriction */
ext_types = frame->ext_types;
if( ( ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE ) != 0 )
{
p = frame->ext_key_usage_raw.p;
end = p + frame->ext_key_usage_raw.len;
ret = mbedtls_asn1_traverse_sequence_of( &p, end,
0xFF, MBEDTLS_ASN1_OID, 0, 0,
x509_crt_check_ext_key_usage_cb,
&cb_ctx );
if( ret == 1 )
ret = 0;
else
ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA;
}
Add x509_crt_check_extended_key_usage()
2014-04-10 15:53:56 +00:00
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_frame_release( crt );
Make use of CRT acquire/release in ExtKeyUsage checking
2019-02-25 18:11:42 +00:00
return( ret );
Add x509_crt_check_extended_key_usage()
2014-04-10 15:53:56 +00:00
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#endif /* MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE */
Add x509_crt_check_extended_key_usage()
2014-04-10 15:53:56 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_X509_CRL_PARSE_C)
- Added CRL revocation support to x509parse_verify() - Fixed an off-by-one allocation in ssl_set_hostname() - Added CRL support to SSL/TLS code
2009-05-03 10:18:48 +00:00
/*
* Return 1 if the certificate is revoked, or 0 otherwise.
*/
Check whether CRT is revoked by passing its serial number only CRLs reference revoked CRTs through their serial number only.
2019-02-22 15:01:03 +00:00
static int x509_serial_is_revoked( unsigned char const *serial,
size_t serial_len,
const mbedtls_x509_crl *crl )
- Added CRL revocation support to x509parse_verify() - Fixed an off-by-one allocation in ssl_set_hostname() - Added CRL support to SSL/TLS code
2009-05-03 10:18:48 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
const mbedtls_x509_crl_entry *cur = &crl->entry;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
- Added CRL revocation support to x509parse_verify() - Fixed an off-by-one allocation in ssl_set_hostname() - Added CRL support to SSL/TLS code
2009-05-03 10:18:48 +00:00
while( cur != NULL && cur->serial.len != 0 )
{
Check whether CRT is revoked by passing its serial number only CRLs reference revoked CRTs through their serial number only.
2019-02-22 15:01:03 +00:00
if( serial_len == cur->serial.len &&
memcmp( serial, cur->serial.p, serial_len ) == 0 )
- Added CRL revocation support to x509parse_verify() - Fixed an off-by-one allocation in ssl_set_hostname() - Added CRL support to SSL/TLS code
2009-05-03 10:18:48 +00:00
{
Rename boolean functions to be clearer
2015-06-02 09:38:50 +00:00
if( mbedtls_x509_time_is_past( &cur->revocation_date ) )
- Added CRL revocation support to x509parse_verify() - Fixed an off-by-one allocation in ssl_set_hostname() - Added CRL support to SSL/TLS code
2009-05-03 10:18:48 +00:00
return( 1 );
}
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
- Added CRL revocation support to x509parse_verify() - Fixed an off-by-one allocation in ssl_set_hostname() - Added CRL support to SSL/TLS code
2009-05-03 10:18:48 +00:00
cur = cur->next;
}
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
return( 0 );
}
Check whether CRT is revoked by passing its serial number only CRLs reference revoked CRTs through their serial number only.
2019-02-22 15:01:03 +00:00
int mbedtls_x509_crt_is_revoked( const mbedtls_x509_crt *crt,
const mbedtls_x509_crl *crl )
{
Make use of CRT acquire/release in x509_serial_is_revoked()
2019-02-25 18:12:00 +00:00
int ret;
Don't allow change of CRT frame returned by x509_crt_frame_acquire()
2019-05-20 15:26:34 +00:00
mbedtls_x509_crt_frame const *frame;
Make use of CRT acquire/release in x509_serial_is_revoked()
2019-02-25 18:12:00 +00:00
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
Make use of CRT acquire/release in x509_serial_is_revoked()
2019-02-25 18:12:00 +00:00
if( ret != 0 )
return( MBEDTLS_ERR_X509_FATAL_ERROR );
ret = x509_serial_is_revoked( frame->serial.p,
frame->serial.len,
crl );
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_frame_release( crt );
Make use of CRT acquire/release in x509_serial_is_revoked()
2019-02-25 18:12:00 +00:00
return( ret );
Check whether CRT is revoked by passing its serial number only CRLs reference revoked CRTs through their serial number only.
2019-02-22 15:01:03 +00:00
}
- Improved certificate validation and validation against the available CRLs
2011-01-16 21:12:10 +00:00
/*
Clarify documentation about missing CRLs Also tune up some working while at it.
2016-02-22 10:36:55 +00:00
* Check that the given certificate is not revoked according to the CRL.
Fix some style issues and comment typos
2017-10-18 12:20:24 +00:00
* Skip validation if no CRL for the given CA is present.
- Improved certificate validation and validation against the available CRLs
2011-01-16 21:12:10 +00:00
*/
Check whether CRT is revoked by passing its serial number only CRLs reference revoked CRTs through their serial number only.
2019-02-22 15:01:03 +00:00
static int x509_crt_verifycrl( unsigned char *crt_serial,
size_t crt_serial_len,
Make use of CRT acquire/release in x509_crt_verifycrl()
2019-02-25 18:12:46 +00:00
mbedtls_x509_crt *ca_crt,
Create cert profile API (unimplemented yet)
2015-06-15 08:39:46 +00:00
mbedtls_x509_crl *crl_list,
const mbedtls_x509_crt_profile *profile )
- Improved certificate validation and validation against the available CRLs
2011-01-16 21:12:10 +00:00
{
Make use of CRT acquire/release in x509_crt_verifycrl()
2019-02-25 18:12:46 +00:00
int ret;
- Improved certificate validation and validation against the available CRLs
2011-01-16 21:12:10 +00:00
int flags = 0;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
unsigned char hash[MBEDTLS_MD_MAX_SIZE];
const mbedtls_md_info_t *md_info;
Make use of CRT acquire/release in x509_crt_verifycrl()
2019-02-25 18:12:46 +00:00
mbedtls_x509_buf_raw ca_subject;
mbedtls_pk_context *pk;
int can_sign;
- Improved certificate validation and validation against the available CRLs
2011-01-16 21:12:10 +00:00
Make use of CRT acquire/release in x509_crt_verifycrl()
2019-02-25 18:12:46 +00:00
if( ca_crt == NULL )
- Revamped x509_verify() and the SSL f_vrfy callback implementations
2012-09-28 07:10:55 +00:00
return( flags );
Make use of CRT acquire/release in x509_crt_verifycrl()
2019-02-25 18:12:46 +00:00
{
Don't allow change of CRT frame returned by x509_crt_frame_acquire()
2019-05-20 15:26:34 +00:00
mbedtls_x509_crt_frame const *ca;
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
ret = mbedtls_x509_crt_frame_acquire( ca_crt, &ca );
Make use of CRT acquire/release in x509_crt_verifycrl()
2019-02-25 18:12:46 +00:00
if( ret != 0 )
return( MBEDTLS_X509_BADCRL_NOT_TRUSTED );
ca_subject = ca->subject_raw;
can_sign = 0;
if( x509_crt_check_key_usage_frame( ca,
MBEDTLS_X509_KU_CRL_SIGN ) == 0 )
{
can_sign = 1;
}
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_frame_release( ca_crt );
Make use of CRT acquire/release in x509_crt_verifycrl()
2019-02-25 18:12:46 +00:00
}
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
ret = mbedtls_x509_crt_pk_acquire( ca_crt, &pk );
Make use of CRT acquire/release in x509_crt_verifycrl()
2019-02-25 18:12:46 +00:00
if( ret != 0 )
return( MBEDTLS_X509_BADCRL_NOT_TRUSTED );
- Revamped x509_verify() and the SSL f_vrfy callback implementations
2012-09-28 07:10:55 +00:00
while( crl_list != NULL )
- Improved certificate validation and validation against the available CRLs
2011-01-16 21:12:10 +00:00
{
- Revamped x509_verify() and the SSL f_vrfy callback implementations
2012-09-28 07:10:55 +00:00
if( crl_list->version == 0 ||
Solely use raw X.509 name data references including SEQUENCE header So far, the CRT frame structure `mbedtls_x509_crt_frame` used as `issuer_raw` and `subject_raw` the _content_ of the ASN.1 name structure for issuer resp. subject. This was in contrast to the fields `issuer_raw` and `subject_raw` from the legacy `mbedtls_x509_crt` structure, and caused some information duplication by having both variants `xxx_no_hdr` and `xxx_with_hdr` in `mbedtls_x509_crt` and `mbedtls_x509_crt_frame`. This commit removes this mismatch by solely using the legacy form of `issuer_raw` and `subject_raw`, i.e. those _including_ the ASN.1 name header.
2019-03-04 14:43:43 +00:00
mbedtls_x509_name_cmp_raw( &crl_list->issuer_raw,
Make use of CRT acquire/release in x509_crt_verifycrl()
2019-02-25 18:12:46 +00:00
&ca_subject, NULL, NULL ) != 0 )
- Improved certificate validation and validation against the available CRLs
2011-01-16 21:12:10 +00:00
{
crl_list = crl_list->next;
continue;
}
Add keyUsage checking for CAs
2014-04-08 13:10:07 +00:00
/*
* Check if the CA is configured to sign CRLs
*/
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
Make use of CRT acquire/release in x509_crt_verifycrl()
2019-02-25 18:12:46 +00:00
if( !can_sign )
Add keyUsage checking for CAs
2014-04-08 13:10:07 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
Add keyUsage checking for CAs
2014-04-08 13:10:07 +00:00
break;
}
#endif
- Improved certificate validation and validation against the available CRLs
2011-01-16 21:12:10 +00:00
/*
* Check if CRL is correctly signed by the trusted CA
*/
Implement cert profile checking
2015-06-15 14:17:55 +00:00
if( x509_profile_check_md_alg( profile, crl_list->sig_md ) != 0 )
flags |= MBEDTLS_X509_BADCRL_BAD_MD;
if( x509_profile_check_pk_alg( profile, crl_list->sig_pk ) != 0 )
flags |= MBEDTLS_X509_BADCRL_BAD_PK;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
md_info = mbedtls_md_info_from_type( crl_list->sig_md );
Improve handling of md errors in X.509 md() already checks for md_info == NULL. Also, in the future it might also return other errors (eg hardware errors if acceleration is used), so it make more sense to check its return value than to check for NULL ourselves and then assume no other error can occur. Also, currently, md_info == NULL can never happen except if the MD and OID modules get out of sync, or if the user messes with members of the x509_crt structure directly. This commit does not change the current behaviour, which is to treat MD errors the same way as a bad signature or no trusted root.
2017-06-26 10:22:17 +00:00
if( mbedtls_md( md_info, crl_list->tbs.p, crl_list->tbs.len, hash ) != 0 )
OID functionality moved to a separate module. A new OID module has been created that contains the main OID searching functionality based on type-dependent arrays. A base type is used to contain the basic values (oid_descriptor_t) and that type is extended to contain type specific information (like a pk_alg_t). As a result the rsa sign and verify function prototypes have changed. They now expect a md_type_t identifier instead of the removed RSA_SIG_XXX defines. All OID definitions have been moved to oid.h All OID matching code is in the OID module. The RSA PKCS#1 functions cleaned up as a result and adapted to use the MD layer. The SSL layer cleanup up as a result and adapted to use the MD layer. The X509 parser cleaned up and matches OIDs in certificates with new module and adapted to use the MD layer. The X509 writer cleaned up and adapted to use the MD layer. Apps and tests modified accordingly
2013-04-07 20:00:46 +00:00
{
Improve handling of md errors in X.509 md() already checks for md_info == NULL. Also, in the future it might also return other errors (eg hardware errors if acceleration is used), so it make more sense to check its return value than to check for NULL ourselves and then assume no other error can occur. Also, currently, md_info == NULL can never happen except if the MD and OID modules get out of sync, or if the user messes with members of the x509_crt structure directly. This commit does not change the current behaviour, which is to treat MD errors the same way as a bad signature or no trusted root.
2017-06-26 10:22:17 +00:00
/* Note: this can't happen except after an internal error */
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
OID functionality moved to a separate module. A new OID module has been created that contains the main OID searching functionality based on type-dependent arrays. A base type is used to contain the basic values (oid_descriptor_t) and that type is extended to contain type specific information (like a pk_alg_t). As a result the rsa sign and verify function prototypes have changed. They now expect a md_type_t identifier instead of the removed RSA_SIG_XXX defines. All OID definitions have been moved to oid.h All OID matching code is in the OID module. The RSA PKCS#1 functions cleaned up as a result and adapted to use the MD layer. The SSL layer cleanup up as a result and adapted to use the MD layer. The X509 parser cleaned up and matches OIDs in certificates with new module and adapted to use the MD layer. The X509 writer cleaned up and adapted to use the MD layer. Apps and tests modified accordingly
2013-04-07 20:00:46 +00:00
break;
}
- Improved certificate validation and validation against the available CRLs
2011-01-16 21:12:10 +00:00
Make use of CRT acquire/release in x509_crt_verifycrl()
2019-02-25 18:12:46 +00:00
if( x509_profile_check_key( profile, pk ) != 0 )
Implement cert profile checking
2015-06-15 14:17:55 +00:00
flags |= MBEDTLS_X509_BADCERT_BAD_KEY;
Create cert profile API (unimplemented yet)
2015-06-15 08:39:46 +00:00
Make use of CRT acquire/release in x509_crt_verifycrl()
2019-02-25 18:12:46 +00:00
if( mbedtls_pk_verify_ext( crl_list->sig_pk, crl_list->sig_opts, pk,
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
crl_list->sig_md, hash, mbedtls_md_get_size( md_info ),
Also verify CRLs signed with RSASSA-PSS
2014-06-05 15:53:52 +00:00
crl_list->sig.p, crl_list->sig.len ) != 0 )
- Improved certificate validation and validation against the available CRLs
2011-01-16 21:12:10 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
Add a PK can_do() method and simplify code
2013-08-12 16:41:18 +00:00
break;
- Improved certificate validation and validation against the available CRLs
2011-01-16 21:12:10 +00:00
}
/*
* Check for validity of CRL (Do not drop out)
*/
Rename boolean functions to be clearer
2015-06-02 09:38:50 +00:00
if( mbedtls_x509_time_is_past( &crl_list->next_update ) )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
flags |= MBEDTLS_X509_BADCRL_EXPIRED;
- Improved certificate validation and validation against the available CRLs
2011-01-16 21:12:10 +00:00
Rename boolean functions to be clearer
2015-06-02 09:38:50 +00:00
if( mbedtls_x509_time_is_future( &crl_list->this_update ) )
Fix some X509 macro names For some reason, during the great renaming, some names that should have been prefixed with MBEDTLS_X509_ have only been prefixed with MBEDTLS_
2015-04-20 11:19:02 +00:00
flags |= MBEDTLS_X509_BADCRL_FUTURE;
Reject certs and CRLs from the future
2014-03-10 12:15:18 +00:00
- Improved certificate validation and validation against the available CRLs
2011-01-16 21:12:10 +00:00
/*
* Check if certificate is revoked
*/
Check whether CRT is revoked by passing its serial number only CRLs reference revoked CRTs through their serial number only.
2019-02-22 15:01:03 +00:00
if( x509_serial_is_revoked( crt_serial, crt_serial_len,
crl_list ) )
- Improved certificate validation and validation against the available CRLs
2011-01-16 21:12:10 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
flags |= MBEDTLS_X509_BADCERT_REVOKED;
- Improved certificate validation and validation against the available CRLs
2011-01-16 21:12:10 +00:00
break;
}
crl_list = crl_list->next;
}
Implement cert profile checking
2015-06-15 14:17:55 +00:00
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_pk_release( ca_crt );
Fix code styling for return statements
2014-06-17 12:06:49 +00:00
return( flags );
- Improved certificate validation and validation against the available CRLs
2011-01-16 21:12:10 +00:00
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#endif /* MBEDTLS_X509_CRL_PARSE_C */
- Improved certificate validation and validation against the available CRLs
2011-01-16 21:12:10 +00:00
Factor duplicated code into function
2017-07-03 17:26:25 +00:00
/*
* Check the signature of a certificate by its parent
*/
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
static int x509_crt_check_signature( const mbedtls_x509_crt_sig_info *sig_info,
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
mbedtls_x509_crt *parent,
mbedtls_x509_crt_restart_ctx *rs_ctx )
Factor duplicated code into function
2017-07-03 17:26:25 +00:00
{
Make use of CRT acquire/release for X.509 CRT signature checking
2019-02-25 14:45:31 +00:00
int ret;
mbedtls_pk_context *pk;
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
ret = mbedtls_x509_crt_pk_acquire( parent, &pk );
Make use of CRT acquire/release for X.509 CRT signature checking
2019-02-25 14:45:31 +00:00
if( ret != 0 )
return( MBEDTLS_ERR_X509_FATAL_ERROR );
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
/* Skip expensive computation on obvious mismatch */
Make use of CRT acquire/release for X.509 CRT signature checking
2019-02-25 14:45:31 +00:00
if( ! mbedtls_pk_can_do( pk, sig_info->sig_pk ) )
{
ret = -1;
goto exit;
}
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
Make use of CRT acquire/release for X.509 CRT signature checking
2019-02-25 14:45:31 +00:00
#if !( defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE) )
((void) rs_ctx);
#else
if( rs_ctx != NULL && sig_info->sig_pk == MBEDTLS_PK_ECDSA )
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
{
Make use of CRT acquire/release for X.509 CRT signature checking
2019-02-25 14:45:31 +00:00
ret = mbedtls_pk_verify_restartable( pk,
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
sig_info->sig_md,
sig_info->crt_hash, sig_info->crt_hash_len,
sig_info->sig.p, sig_info->sig.len,
Make use of CRT acquire/release for X.509 CRT signature checking
2019-02-25 14:45:31 +00:00
&rs_ctx->pk );
Factor duplicated code into function
2017-07-03 17:26:25 +00:00
}
Make use of CRT acquire/release for X.509 CRT signature checking
2019-02-25 14:45:31 +00:00
else
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
#endif
Make use of CRT acquire/release for X.509 CRT signature checking
2019-02-25 14:45:31 +00:00
{
ret = mbedtls_pk_verify_ext( sig_info->sig_pk,
sig_info->sig_opts,
pk,
sig_info->sig_md,
sig_info->crt_hash, sig_info->crt_hash_len,
sig_info->sig.p, sig_info->sig.len );
}
Factor duplicated code into function
2017-07-03 17:26:25 +00:00
Make use of CRT acquire/release for X.509 CRT signature checking
2019-02-25 14:45:31 +00:00
exit:
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_pk_release( parent );
Make use of CRT acquire/release for X.509 CRT signature checking
2019-02-25 14:45:31 +00:00
return( ret );
Factor duplicated code into function
2017-07-03 17:26:25 +00:00
}
Factor some common code in x509_verify{,_child}
2014-04-08 11:18:01 +00:00
/*
Factor common parent checking code
2014-04-09 12:30:11 +00:00
* Check if 'parent' is a suitable parent (signing CA) for 'child'.
* Return 0 if yes, -1 if not.
Restore ability to trust non-CA selfsigned EE cert
2014-06-24 09:49:16 +00:00
*
* top means parent is a locally-trusted certificate
Factor some common code in x509_verify{,_child}
2014-04-08 11:18:01 +00:00
*/
Make use of CRT acquire/release searching for issuer in CRT verif. This commit continues rewriting the CRT chain verification to use the new acquire/release framework for CRTs. Specifically, it replaces all member accesses of the current _parent_ CRT by accesses to the respective frame.
2019-02-25 14:46:49 +00:00
static int x509_crt_check_parent( const mbedtls_x509_crt_sig_info *sig_info,
const mbedtls_x509_crt_frame *parent,
Simplify handling of locally trusted EE certs Though this might require one more walk of the list in some cases, this avoid having a check for that deep inside check_parent().
2017-07-03 22:49:31 +00:00
int top )
Factor some common code in x509_verify{,_child}
2014-04-08 11:18:01 +00:00
{
Restore ability to trust non-CA selfsigned EE cert
2014-06-24 09:49:16 +00:00
int need_ca_bit;
Restore ability to use v1 CA if trusted locally
2014-06-19 10:18:08 +00:00
/* Parent must be the issuer */
Make use of CRT acquire/release searching for issuer in CRT verif. This commit continues rewriting the CRT chain verification to use the new acquire/release framework for CRTs. Specifically, it replaces all member accesses of the current _parent_ CRT by accesses to the respective frame.
2019-02-25 14:46:49 +00:00
if( mbedtls_x509_name_cmp_raw( &sig_info->issuer_raw,
&parent->subject_raw,
Add abort condition callback to `mbedtls_x509_name_cmp_raw()` There are three operations that need to be performed on an X.509 name: 1 Initial traversal to check well-formedness of the ASN.1 structure. 2 Comparison between two X.509 name sequences. 3 Checking whether an X.509 name matches a client's ServerName request. Each of these tasks involves traversing the nested ASN.1 structure, In the interest of saving code, we aim to provide a single function which can perform all of the above tasks. The existing comparison function is already suitable not only for task 2, but also for 1: One can simply pass two equal ASN.1 name buffers, in which case the function will succeed if and only if that buffer is a well-formed ASN.1 name. This commit further adds a callback to `mbedtls_x509_name_cmp_raw()` which is called after each successful step in the simultaneous name traversal and comparison; it may perform any operation on the current name and potentially signal that the comparison should be aborted. With that, task 3 can be implemented by passing equal names and a callback which aborts as soon as it finds the desired name component.
2019-02-21 14:31:51 +00:00
NULL, NULL ) != 0 )
Make use of raw comparison function in CRT verification This commit replaces the previous calls to `mbedtls_x509_name_cmp()` during CRT verification (to match child and parent, to check whether a CRT is self-issued, and to match CRLs and CAs) by calls to the new `mbedtls_x509_name_cmp_raw()` using the raw ASN.1 data; it passes the raw buffers introduced in the last commits. The previous name comparison function mbedtls_x509_name_cmp() is now both unused and unneeded, and is removed.
2019-02-21 13:58:38 +00:00
{
Factor common parent checking code
2014-04-09 12:30:11 +00:00
return( -1 );
Make use of raw comparison function in CRT verification This commit replaces the previous calls to `mbedtls_x509_name_cmp()` during CRT verification (to match child and parent, to check whether a CRT is self-issued, and to match CRLs and CAs) by calls to the new `mbedtls_x509_name_cmp_raw()` using the raw ASN.1 data; it passes the raw buffers introduced in the last commits. The previous name comparison function mbedtls_x509_name_cmp() is now both unused and unneeded, and is removed.
2019-02-21 13:58:38 +00:00
}
Factor some common code in x509_verify{,_child}
2014-04-08 11:18:01 +00:00
Restore ability to trust non-CA selfsigned EE cert
2014-06-24 09:49:16 +00:00
/* Parent must have the basicConstraints CA bit set as a general rule */
need_ca_bit = 1;
/* Exception: v1/v2 certificates that are locally trusted. */
if( top && parent->version < 3 )
need_ca_bit = 0;
if( need_ca_bit && ! parent->ca_istrue )
return( -1 );
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
Restore ability to trust non-CA selfsigned EE cert
2014-06-24 09:49:16 +00:00
if( need_ca_bit &&
Make use of CRT acquire/release searching for issuer in CRT verif. This commit continues rewriting the CRT chain verification to use the new acquire/release framework for CRTs. Specifically, it replaces all member accesses of the current _parent_ CRT by accesses to the respective frame.
2019-02-25 14:46:49 +00:00
x509_crt_check_key_usage_frame( parent,
MBEDTLS_X509_KU_KEY_CERT_SIGN ) != 0 )
Restore ability to trust non-CA selfsigned EE cert
2014-06-24 09:49:16 +00:00
{
Factor common parent checking code
2014-04-09 12:30:11 +00:00
return( -1 );
Restore ability to trust non-CA selfsigned EE cert
2014-06-24 09:49:16 +00:00
}
Add keyUsage checking for CAs
2014-04-08 13:10:07 +00:00
#endif
Factor common parent checking code
2014-04-09 12:30:11 +00:00
return( 0 );
Factor some common code in x509_verify{,_child}
2014-04-08 11:18:01 +00:00
}
Factor repeated code into function There are 3 instance that were replaced, but 2 instances of variants of this function exist and will be handled next (the extra parameter that isn't used so far is in preparation for that): - one in verify_child() where path_cnt constraint is handled too - one in verify_top() where there is extra logic to skip parents that are expired or future, but only if there are better parents to be found
2017-06-29 10:27:23 +00:00
/*
Add badtime-skipping feature to new function This is from the morally 5th (and soon obsolete) invocation of this function in verify_top(). Doing this badtime-skipping when we search for a parent in the provided chain is a change of behaviour, but it's backwards-compatible: it can only cause us to accept valid chains that we used to reject before. Eg if the peer has a chain with two version of an intermediate certificate with different validity periods, the first non valid and the second valid - such cases are probably rare or users would have complained already, but it doesn't hurt to handle it properly as it allows for more uniform code.
2017-06-29 10:55:27 +00:00
* Find a suitable parent for child in candidates, or return NULL.
*
* Here suitable is defined as:
Add badkey-skipping to find_parent() This is the last step towards removing the now-duplicated parent-searching code in verify_top()
2017-07-03 16:30:43 +00:00
* 1. subject name matches child's issuer
* 2. if necessary, the CA bit is set and key usage allows signing certs
* 3. for trusted roots, the signature is correct
Call crt_check_signature from one place only
2017-07-14 10:04:14 +00:00
* (for intermediates, the signature is checked and the result reported)
Add badkey-skipping to find_parent() This is the last step towards removing the now-duplicated parent-searching code in verify_top()
2017-07-03 16:30:43 +00:00
* 4. pathlen constraints are satisfied
Add badtime-skipping feature to new function This is from the morally 5th (and soon obsolete) invocation of this function in verify_top(). Doing this badtime-skipping when we search for a parent in the provided chain is a change of behaviour, but it's backwards-compatible: it can only cause us to accept valid chains that we used to reject before. Eg if the peer has a chain with two version of an intermediate certificate with different validity periods, the first non valid and the second valid - such cases are probably rare or users would have complained already, but it doesn't hurt to handle it properly as it allows for more uniform code.
2017-06-29 10:55:27 +00:00
*
Improve some comments, fix some typos+whitespace
2017-08-08 16:09:14 +00:00
* If there's a suitable candidate which is also time-valid, return the first
* such. Otherwise, return the first suitable candidate (or NULL if there is
* none).
Add badtime-skipping feature to new function This is from the morally 5th (and soon obsolete) invocation of this function in verify_top(). Doing this badtime-skipping when we search for a parent in the provided chain is a change of behaviour, but it's backwards-compatible: it can only cause us to accept valid chains that we used to reject before. Eg if the peer has a chain with two version of an intermediate certificate with different validity periods, the first non valid and the second valid - such cases are probably rare or users would have complained already, but it doesn't hurt to handle it properly as it allows for more uniform code.
2017-06-29 10:55:27 +00:00
*
* The rationale for this rule is that someone could have a list of trusted
* roots with two versions on the same root with different validity periods.
* (At least one user reported having such a list and wanted it to just work.)
* The reason we don't just require time-validity is that generally there is
* only one version, and if it's expired we want the flags to state that
* rather than NOT_TRUSTED, as would be the case if we required it here.
Add badkey-skipping to find_parent() This is the last step towards removing the now-duplicated parent-searching code in verify_top()
2017-07-03 16:30:43 +00:00
*
* The rationale for rule 3 (signature for trusted roots) is that users might
* have two versions of the same CA with different keys in their list, and the
Update comments
2017-07-03 22:33:39 +00:00
* way we select the correct one is by checking the signature (as we don't
* rely on key identifier extensions). (This is one way users might choose to
* handle key rollover, another relies on self-issued certs, see [SIRO].)
Better document some function arguments
2017-08-17 08:52:20 +00:00
*
* Arguments:
Improve documentation of some internal functions
2018-03-07 09:00:57 +00:00
* - [in] child: certificate for which we're looking for a parent
* - [in] candidates: chained list of potential parents
Merge branch 'development' into iotssl-1260-non-blocking-ecc-restricted Summary of merge conflicts: include/mbedtls/ecdh.h -> documentation style include/mbedtls/ecdsa.h -> documentation style include/mbedtls/ecp.h -> alt style, new error codes, documentation style include/mbedtls/error.h -> new error codes library/error.c -> new error codes (generated anyway) library/ecp.c: - code of an extracted function was changed library/ssl_cli.c: - code addition on one side near code change on the other side (ciphersuite validation) library/x509_crt.c -> various things - top fo file: helper structure added near old zeroize removed - documentation of find_parent_in()'s signature: improved on one side, added arguments on the other side - documentation of find_parent()'s signature: same as above - verify_chain(): variables initialised later to give compiler an opportunity to warn us if not initialised on a code path - find_parent(): funcion structure completely changed, for some reason git tried to insert a paragraph of the old structure... - merge_flags_with_cb(): data structure changed, one line was fixed with a cast to keep MSVC happy, this cast is already in the new version - in verify_restratable(): adjacent independent changes (function signature on one line, variable type on the next) programs/ssl/ssl_client2.c: - testing for IN_PROGRESS return code near idle() (event-driven): don't wait for data in the the socket if ECP_IN_PROGRESS tests/data_files/Makefile: adjacent independent additions tests/suites/test_suite_ecdsa.data: adjacent independent additions tests/suites/test_suite_x509parse.data: adjacent independent additions * development: (1059 commits) Change symlink to hardlink to avoid permission issues Fix out-of-tree testing symlinks on Windows Updated version number to 2.10.0 for release Add a disabled CMAC define in the no-entropy configuration Adapt the ARIA test cases for new ECB function Fix file permissions for ssl.h Add ChangeLog entry for PR#1651 Fix MicroBlaze register typo. Fix typo in doc and copy missing warning Fix edit mistake in cipher_wrap.c Update CTR doc for the 64-bit block cipher Update CTR doc for other 128-bit block ciphers Slightly tune ARIA CTR documentation Remove double declaration of mbedtls_ssl_list_ciphersuites Update CTR documentation Use zeroize function from new platform_util Move to new header style for ALT implementations Add ifdef for selftest in header file Fix typo in comments Use more appropriate type for local variable ...
2018-06-12 10:40:54 +00:00
* - [out] r_parent: parent found (or NULL)
* - [out] r_signature_is_good: 1 if child signature by parent is valid, or 0
Improve documentation of some internal functions
2018-03-07 09:00:57 +00:00
* - [in] top: 1 if candidates consists of trusted roots, ie we're at the top
* of the chain, 0 otherwise
* - [in] path_cnt: number of intermediates seen so far
* - [in] self_cnt: number of self-signed intermediates seen so far
* (will never be greater than path_cnt)
Merge branch 'development' into iotssl-1260-non-blocking-ecc-restricted Summary of merge conflicts: include/mbedtls/ecdh.h -> documentation style include/mbedtls/ecdsa.h -> documentation style include/mbedtls/ecp.h -> alt style, new error codes, documentation style include/mbedtls/error.h -> new error codes library/error.c -> new error codes (generated anyway) library/ecp.c: - code of an extracted function was changed library/ssl_cli.c: - code addition on one side near code change on the other side (ciphersuite validation) library/x509_crt.c -> various things - top fo file: helper structure added near old zeroize removed - documentation of find_parent_in()'s signature: improved on one side, added arguments on the other side - documentation of find_parent()'s signature: same as above - verify_chain(): variables initialised later to give compiler an opportunity to warn us if not initialised on a code path - find_parent(): funcion structure completely changed, for some reason git tried to insert a paragraph of the old structure... - merge_flags_with_cb(): data structure changed, one line was fixed with a cast to keep MSVC happy, this cast is already in the new version - in verify_restratable(): adjacent independent changes (function signature on one line, variable type on the next) programs/ssl/ssl_client2.c: - testing for IN_PROGRESS return code near idle() (event-driven): don't wait for data in the the socket if ECP_IN_PROGRESS tests/data_files/Makefile: adjacent independent additions tests/suites/test_suite_ecdsa.data: adjacent independent additions tests/suites/test_suite_x509parse.data: adjacent independent additions * development: (1059 commits) Change symlink to hardlink to avoid permission issues Fix out-of-tree testing symlinks on Windows Updated version number to 2.10.0 for release Add a disabled CMAC define in the no-entropy configuration Adapt the ARIA test cases for new ECB function Fix file permissions for ssl.h Add ChangeLog entry for PR#1651 Fix MicroBlaze register typo. Fix typo in doc and copy missing warning Fix edit mistake in cipher_wrap.c Update CTR doc for the 64-bit block cipher Update CTR doc for other 128-bit block ciphers Slightly tune ARIA CTR documentation Remove double declaration of mbedtls_ssl_list_ciphersuites Update CTR documentation Use zeroize function from new platform_util Move to new header style for ALT implementations Add ifdef for selftest in header file Fix typo in comments Use more appropriate type for local variable ...
2018-06-12 10:40:54 +00:00
* - [in-out] rs_ctx: context for restarting operations
Improve documentation of some internal functions
2018-03-07 09:00:57 +00:00
*
* Return value:
Merge branch 'development' into iotssl-1260-non-blocking-ecc-restricted Summary of merge conflicts: include/mbedtls/ecdh.h -> documentation style include/mbedtls/ecdsa.h -> documentation style include/mbedtls/ecp.h -> alt style, new error codes, documentation style include/mbedtls/error.h -> new error codes library/error.c -> new error codes (generated anyway) library/ecp.c: - code of an extracted function was changed library/ssl_cli.c: - code addition on one side near code change on the other side (ciphersuite validation) library/x509_crt.c -> various things - top fo file: helper structure added near old zeroize removed - documentation of find_parent_in()'s signature: improved on one side, added arguments on the other side - documentation of find_parent()'s signature: same as above - verify_chain(): variables initialised later to give compiler an opportunity to warn us if not initialised on a code path - find_parent(): funcion structure completely changed, for some reason git tried to insert a paragraph of the old structure... - merge_flags_with_cb(): data structure changed, one line was fixed with a cast to keep MSVC happy, this cast is already in the new version - in verify_restratable(): adjacent independent changes (function signature on one line, variable type on the next) programs/ssl/ssl_client2.c: - testing for IN_PROGRESS return code near idle() (event-driven): don't wait for data in the the socket if ECP_IN_PROGRESS tests/data_files/Makefile: adjacent independent additions tests/suites/test_suite_ecdsa.data: adjacent independent additions tests/suites/test_suite_x509parse.data: adjacent independent additions * development: (1059 commits) Change symlink to hardlink to avoid permission issues Fix out-of-tree testing symlinks on Windows Updated version number to 2.10.0 for release Add a disabled CMAC define in the no-entropy configuration Adapt the ARIA test cases for new ECB function Fix file permissions for ssl.h Add ChangeLog entry for PR#1651 Fix MicroBlaze register typo. Fix typo in doc and copy missing warning Fix edit mistake in cipher_wrap.c Update CTR doc for the 64-bit block cipher Update CTR doc for other 128-bit block ciphers Slightly tune ARIA CTR documentation Remove double declaration of mbedtls_ssl_list_ciphersuites Update CTR documentation Use zeroize function from new platform_util Move to new header style for ALT implementations Add ifdef for selftest in header file Fix typo in comments Use more appropriate type for local variable ...
2018-06-12 10:40:54 +00:00
* - 0 on success
* - MBEDTLS_ERR_ECP_IN_PROGRESS otherwise
Factor repeated code into function There are 3 instance that were replaced, but 2 instances of variants of this function exist and will be handled next (the extra parameter that isn't used so far is in preparation for that): - one in verify_child() where path_cnt constraint is handled too - one in verify_top() where there is extra logic to skip parents that are expired or future, but only if there are better parents to be found
2017-06-29 10:27:23 +00:00
*/
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
static int x509_crt_find_parent_in(
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
mbedtls_x509_crt_sig_info const *child_sig,
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
mbedtls_x509_crt *candidates,
mbedtls_x509_crt **r_parent,
int *r_signature_is_good,
int top,
Fix MSVC 64-bit warnings "conversion from size_t to int, possible loss of data"
2017-08-28 11:25:55 +00:00
unsigned path_cnt,
unsigned self_cnt,
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
mbedtls_x509_crt_restart_ctx *rs_ctx )
Factor repeated code into function There are 3 instance that were replaced, but 2 instances of variants of this function exist and will be handled next (the extra parameter that isn't used so far is in preparation for that): - one in verify_child() where path_cnt constraint is handled too - one in verify_top() where there is extra logic to skip parents that are expired or future, but only if there are better parents to be found
2017-06-29 10:27:23 +00:00
{
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
int ret;
Make use of CRT acquire/release searching for issuer in CRT verif. This commit continues rewriting the CRT chain verification to use the new acquire/release framework for CRTs. Specifically, it replaces all member accesses of the current _parent_ CRT by accesses to the respective frame.
2019-02-25 14:46:49 +00:00
mbedtls_x509_crt *parent_crt, *fallback_parent;
Rename internal variable for consistency
2018-07-02 10:33:14 +00:00
int signature_is_good, fallback_signature_is_good;
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Clarify state handling in find_parent(_in)()
2017-08-23 09:20:48 +00:00
/* did we have something in progress? */
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
if( rs_ctx != NULL && rs_ctx->parent != NULL )
{
Clarify state handling in find_parent(_in)()
2017-08-23 09:20:48 +00:00
/* restore saved state */
Make use of CRT acquire/release searching for issuer in CRT verif. This commit continues rewriting the CRT chain verification to use the new acquire/release framework for CRTs. Specifically, it replaces all member accesses of the current _parent_ CRT by accesses to the respective frame.
2019-02-25 14:46:49 +00:00
parent_crt = rs_ctx->parent;
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
fallback_parent = rs_ctx->fallback_parent;
Rename internal variable for consistency
2018-07-02 10:33:14 +00:00
fallback_signature_is_good = rs_ctx->fallback_signature_is_good;
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
Clarify state handling in find_parent(_in)()
2017-08-23 09:20:48 +00:00
/* clear saved state */
rs_ctx->parent = NULL;
rs_ctx->fallback_parent = NULL;
Rename internal variable for consistency
2018-07-02 10:33:14 +00:00
rs_ctx->fallback_signature_is_good = 0;
Clarify state handling in find_parent(_in)()
2017-08-23 09:20:48 +00:00
/* resume where we left */
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
goto check_signature;
}
#endif
fallback_parent = NULL;
Rename internal variable for consistency
2018-07-02 10:33:14 +00:00
fallback_signature_is_good = 0;
Factor repeated code into function There are 3 instance that were replaced, but 2 instances of variants of this function exist and will be handled next (the extra parameter that isn't used so far is in preparation for that): - one in verify_child() where path_cnt constraint is handled too - one in verify_top() where there is extra logic to skip parents that are expired or future, but only if there are better parents to be found
2017-06-29 10:27:23 +00:00
Make use of CRT acquire/release searching for issuer in CRT verif. This commit continues rewriting the CRT chain verification to use the new acquire/release framework for CRTs. Specifically, it replaces all member accesses of the current _parent_ CRT by accesses to the respective frame.
2019-02-25 14:46:49 +00:00
for( parent_crt = candidates; parent_crt != NULL;
parent_crt = parent_crt->next )
Factor repeated code into function There are 3 instance that were replaced, but 2 instances of variants of this function exist and will be handled next (the extra parameter that isn't used so far is in preparation for that): - one in verify_child() where path_cnt constraint is handled too - one in verify_top() where there is extra logic to skip parents that are expired or future, but only if there are better parents to be found
2017-06-29 10:27:23 +00:00
{
Check validity of potential parent before checking signature The function `x509_crt_find_parent_in()` traverses a list of CRTs to find a potential parent to a given CRT. So far, the logic was the following: For each candidate, - check basic parenting skills (mostly name match) - verify signature - verify validity This order is insuitable for the new acquire/release layer of indirection when dealing with CRTs, because we either have to query the candidate's CRT frame twice, or query frame and PK simultaneously. This commit moves the validity check to the beginning of the routine to allow querying for the frame and then for the PK. The entry point for restartable ECC needs to be moved for that to not forget the validity-flag while pausing ECC computations.
2019-02-24 17:47:46 +00:00
int parent_valid, parent_match, path_len_ok;
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
check_signature:
#endif
parent_valid = parent_match = path_len_ok = 0;
{
Don't allow change of CRT frame returned by x509_crt_frame_acquire()
2019-05-20 15:26:34 +00:00
mbedtls_x509_crt_frame const *parent;
Check validity of potential parent before checking signature The function `x509_crt_find_parent_in()` traverses a list of CRTs to find a potential parent to a given CRT. So far, the logic was the following: For each candidate, - check basic parenting skills (mostly name match) - verify signature - verify validity This order is insuitable for the new acquire/release layer of indirection when dealing with CRTs, because we either have to query the candidate's CRT frame twice, or query frame and PK simultaneously. This commit moves the validity check to the beginning of the routine to allow querying for the frame and then for the PK. The entry point for restartable ECC needs to be moved for that to not forget the validity-flag while pausing ECC computations.
2019-02-24 17:47:46 +00:00
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
ret = mbedtls_x509_crt_frame_acquire( parent_crt, &parent );
Make use of CRT acquire/release searching for issuer in CRT verif. This commit continues rewriting the CRT chain verification to use the new acquire/release framework for CRTs. Specifically, it replaces all member accesses of the current _parent_ CRT by accesses to the respective frame.
2019-02-25 14:46:49 +00:00
if( ret != 0 )
return( MBEDTLS_ERR_X509_FATAL_ERROR );
Factor repeated code into function There are 3 instance that were replaced, but 2 instances of variants of this function exist and will be handled next (the extra parameter that isn't used so far is in preparation for that): - one in verify_child() where path_cnt constraint is handled too - one in verify_top() where there is extra logic to skip parents that are expired or future, but only if there are better parents to be found
2017-06-29 10:27:23 +00:00
Fix certificate validity checking logic to work with !TIME_DATE If MBEDTLS_HAVE_TIME_DATE is undefined, the functions `mbedtls_x509_time_is_past()` and `mbedtls_x509_time_is_future()` are still defined but return `0` (that is, no time is seen to in the past or future). To maintain functional correctness, this means that these functions have to be called in a way where the condition being checked for is the erroneous one: Concretely, one shouldn't check that a CRT's `validFrom` is in the past, or that its `validTo` is in the future, because that would fail if !MBEDTLS_HAVE_TIME_DATE. Instead, one should check that `validFrom` is NOT in the future, and `validTo` is NOT in the past. That was the logic previously, but an uncautious change during transition to X.509 on-demand parsing has changed it. This commit fixes this.
2019-06-10 10:14:24 +00:00
if( !mbedtls_x509_time_is_past( &parent->valid_to ) &&
!mbedtls_x509_time_is_future( &parent->valid_from ) )
Make use of CRT acquire/release searching for issuer in CRT verif. This commit continues rewriting the CRT chain verification to use the new acquire/release framework for CRTs. Specifically, it replaces all member accesses of the current _parent_ CRT by accesses to the respective frame.
2019-02-25 14:46:49 +00:00
{
parent_valid = 1;
}
/* basic parenting skills (name, CA bit, key usage) */
if( x509_crt_check_parent( child_sig, parent, top ) == 0 )
parent_match = 1;
/* +1 because the stored max_pathlen is 1 higher
* than the actual value */
if( !( parent->max_pathlen > 0 &&
(size_t) parent->max_pathlen < 1 + path_cnt - self_cnt ) )
{
path_len_ok = 1;
}
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_frame_release( parent_crt );
Factor one more occurrence of code into function This may look like a behaviour change because one check has been added to the function that was previously done in only one of the 3 call sites. However it is not, because: - for the 2 call sites in verify(), the test always succeeds as path_cnt is 0. - for the call site in verify_child(), the same test was done later anyway in verify_top()
2017-06-29 10:38:42 +00:00
}
Check validity of potential parent before checking signature The function `x509_crt_find_parent_in()` traverses a list of CRTs to find a potential parent to a given CRT. So far, the logic was the following: For each candidate, - check basic parenting skills (mostly name match) - verify signature - verify validity This order is insuitable for the new acquire/release layer of indirection when dealing with CRTs, because we either have to query the candidate's CRT frame twice, or query frame and PK simultaneously. This commit moves the validity check to the beginning of the routine to allow querying for the frame and then for the PK. The entry point for restartable ECC needs to be moved for that to not forget the validity-flag while pausing ECC computations.
2019-02-24 17:47:46 +00:00
if( parent_match == 0 || path_len_ok == 0 )
continue;
Add badkey-skipping to find_parent() This is the last step towards removing the now-duplicated parent-searching code in verify_top()
2017-07-03 16:30:43 +00:00
/* Signature */
Make use of CRT acquire/release searching for issuer in CRT verif. This commit continues rewriting the CRT chain verification to use the new acquire/release framework for CRTs. Specifically, it replaces all member accesses of the current _parent_ CRT by accesses to the respective frame.
2019-02-25 14:46:49 +00:00
ret = x509_crt_check_signature( child_sig, parent_crt, rs_ctx );
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
if( rs_ctx != NULL && ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
{
/* save state */
Make use of CRT acquire/release searching for issuer in CRT verif. This commit continues rewriting the CRT chain verification to use the new acquire/release framework for CRTs. Specifically, it replaces all member accesses of the current _parent_ CRT by accesses to the respective frame.
2019-02-25 14:46:49 +00:00
rs_ctx->parent = parent_crt;
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
rs_ctx->fallback_parent = fallback_parent;
Rename internal variable for consistency
2018-07-02 10:33:14 +00:00
rs_ctx->fallback_signature_is_good = fallback_signature_is_good;
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
return( ret );
}
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
#else
(void) ret;
#endif
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
signature_is_good = ret == 0;
if( top && ! signature_is_good )
Factor duplicated code into function
2017-07-03 17:26:25 +00:00
continue;
Add badkey-skipping to find_parent() This is the last step towards removing the now-duplicated parent-searching code in verify_top()
2017-07-03 16:30:43 +00:00
Improve some comments, fix some typos+whitespace
2017-08-08 16:09:14 +00:00
/* optional time check */
Check validity of potential parent before checking signature The function `x509_crt_find_parent_in()` traverses a list of CRTs to find a potential parent to a given CRT. So far, the logic was the following: For each candidate, - check basic parenting skills (mostly name match) - verify signature - verify validity This order is insuitable for the new acquire/release layer of indirection when dealing with CRTs, because we either have to query the candidate's CRT frame twice, or query frame and PK simultaneously. This commit moves the validity check to the beginning of the routine to allow querying for the frame and then for the PK. The entry point for restartable ECC needs to be moved for that to not forget the validity-flag while pausing ECC computations.
2019-02-24 17:47:46 +00:00
if( !parent_valid )
Add badtime-skipping feature to new function This is from the morally 5th (and soon obsolete) invocation of this function in verify_top(). Doing this badtime-skipping when we search for a parent in the provided chain is a change of behaviour, but it's backwards-compatible: it can only cause us to accept valid chains that we used to reject before. Eg if the peer has a chain with two version of an intermediate certificate with different validity periods, the first non valid and the second valid - such cases are probably rare or users would have complained already, but it doesn't hurt to handle it properly as it allows for more uniform code.
2017-06-29 10:55:27 +00:00
{
Call crt_check_signature from one place only
2017-07-14 10:04:14 +00:00
if( fallback_parent == NULL )
{
Make use of CRT acquire/release searching for issuer in CRT verif. This commit continues rewriting the CRT chain verification to use the new acquire/release framework for CRTs. Specifically, it replaces all member accesses of the current _parent_ CRT by accesses to the respective frame.
2019-02-25 14:46:49 +00:00
fallback_parent = parent_crt;
Rename internal variable for consistency
2018-07-02 10:33:14 +00:00
fallback_signature_is_good = signature_is_good;
Call crt_check_signature from one place only
2017-07-14 10:04:14 +00:00
}
Add badtime-skipping feature to new function This is from the morally 5th (and soon obsolete) invocation of this function in verify_top(). Doing this badtime-skipping when we search for a parent in the provided chain is a change of behaviour, but it's backwards-compatible: it can only cause us to accept valid chains that we used to reject before. Eg if the peer has a chain with two version of an intermediate certificate with different validity periods, the first non valid and the second valid - such cases are probably rare or users would have complained already, but it doesn't hurt to handle it properly as it allows for more uniform code.
2017-06-29 10:55:27 +00:00
continue;
}
Factor repeated code into function There are 3 instance that were replaced, but 2 instances of variants of this function exist and will be handled next (the extra parameter that isn't used so far is in preparation for that): - one in verify_child() where path_cnt constraint is handled too - one in verify_top() where there is extra logic to skip parents that are expired or future, but only if there are better parents to be found
2017-06-29 10:27:23 +00:00
break;
}
Make use of CRT acquire/release searching for issuer in CRT verif. This commit continues rewriting the CRT chain verification to use the new acquire/release framework for CRTs. Specifically, it replaces all member accesses of the current _parent_ CRT by accesses to the respective frame.
2019-02-25 14:46:49 +00:00
if( parent_crt != NULL )
Call crt_check_signature from one place only
2017-07-14 10:04:14 +00:00
{
Make use of CRT acquire/release searching for issuer in CRT verif. This commit continues rewriting the CRT chain verification to use the new acquire/release framework for CRTs. Specifically, it replaces all member accesses of the current _parent_ CRT by accesses to the respective frame.
2019-02-25 14:46:49 +00:00
*r_parent = parent_crt;
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
*r_signature_is_good = signature_is_good;
}
else
{
*r_parent = fallback_parent;
Rename internal variable for consistency
2018-07-02 10:33:14 +00:00
*r_signature_is_good = fallback_signature_is_good;
Call crt_check_signature from one place only
2017-07-14 10:04:14 +00:00
}
Add badtime-skipping feature to new function This is from the morally 5th (and soon obsolete) invocation of this function in verify_top(). Doing this badtime-skipping when we search for a parent in the provided chain is a change of behaviour, but it's backwards-compatible: it can only cause us to accept valid chains that we used to reject before. Eg if the peer has a chain with two version of an intermediate certificate with different validity periods, the first non valid and the second valid - such cases are probably rare or users would have complained already, but it doesn't hurt to handle it properly as it allows for more uniform code.
2017-06-29 10:55:27 +00:00
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
return( 0 );
Factor repeated code into function There are 3 instance that were replaced, but 2 instances of variants of this function exist and will be handled next (the extra parameter that isn't used so far is in preparation for that): - one in verify_child() where path_cnt constraint is handled too - one in verify_top() where there is extra logic to skip parents that are expired or future, but only if there are better parents to be found
2017-06-29 10:27:23 +00:00
}
Move code to separate function for readability
2017-07-03 23:01:39 +00:00
/*
* Find a parent in trusted CAs or the provided chain, or return NULL.
*
* Searches in trusted CAs first, and return the first suitable parent found
* (see find_parent_in() for definition of suitable).
Better document some function arguments
2017-08-17 08:52:20 +00:00
*
* Arguments:
Improve documentation of some internal functions
2018-03-07 09:00:57 +00:00
* - [in] child: certificate for which we're looking for a parent, followed
* by a chain of possible intermediates
Merge branch 'development' into iotssl-1260-non-blocking-ecc-restricted Summary of merge conflicts: include/mbedtls/ecdh.h -> documentation style include/mbedtls/ecdsa.h -> documentation style include/mbedtls/ecp.h -> alt style, new error codes, documentation style include/mbedtls/error.h -> new error codes library/error.c -> new error codes (generated anyway) library/ecp.c: - code of an extracted function was changed library/ssl_cli.c: - code addition on one side near code change on the other side (ciphersuite validation) library/x509_crt.c -> various things - top fo file: helper structure added near old zeroize removed - documentation of find_parent_in()'s signature: improved on one side, added arguments on the other side - documentation of find_parent()'s signature: same as above - verify_chain(): variables initialised later to give compiler an opportunity to warn us if not initialised on a code path - find_parent(): funcion structure completely changed, for some reason git tried to insert a paragraph of the old structure... - merge_flags_with_cb(): data structure changed, one line was fixed with a cast to keep MSVC happy, this cast is already in the new version - in verify_restratable(): adjacent independent changes (function signature on one line, variable type on the next) programs/ssl/ssl_client2.c: - testing for IN_PROGRESS return code near idle() (event-driven): don't wait for data in the the socket if ECP_IN_PROGRESS tests/data_files/Makefile: adjacent independent additions tests/suites/test_suite_ecdsa.data: adjacent independent additions tests/suites/test_suite_x509parse.data: adjacent independent additions * development: (1059 commits) Change symlink to hardlink to avoid permission issues Fix out-of-tree testing symlinks on Windows Updated version number to 2.10.0 for release Add a disabled CMAC define in the no-entropy configuration Adapt the ARIA test cases for new ECB function Fix file permissions for ssl.h Add ChangeLog entry for PR#1651 Fix MicroBlaze register typo. Fix typo in doc and copy missing warning Fix edit mistake in cipher_wrap.c Update CTR doc for the 64-bit block cipher Update CTR doc for other 128-bit block ciphers Slightly tune ARIA CTR documentation Remove double declaration of mbedtls_ssl_list_ciphersuites Update CTR documentation Use zeroize function from new platform_util Move to new header style for ALT implementations Add ifdef for selftest in header file Fix typo in comments Use more appropriate type for local variable ...
2018-06-12 10:40:54 +00:00
* - [in] trust_ca: list of locally trusted certificates
* - [out] parent: parent found (or NULL)
* - [out] parent_is_trusted: 1 if returned `parent` is trusted, or 0
* - [out] signature_is_good: 1 if child signature by parent is valid, or 0
* - [in] path_cnt: number of links in the chain so far (EE -> ... -> child)
* - [in] self_cnt: number of self-signed certs in the chain so far
Improve documentation of some internal functions
2018-03-07 09:00:57 +00:00
* (will always be no greater than path_cnt)
Merge branch 'development' into iotssl-1260-non-blocking-ecc-restricted Summary of merge conflicts: include/mbedtls/ecdh.h -> documentation style include/mbedtls/ecdsa.h -> documentation style include/mbedtls/ecp.h -> alt style, new error codes, documentation style include/mbedtls/error.h -> new error codes library/error.c -> new error codes (generated anyway) library/ecp.c: - code of an extracted function was changed library/ssl_cli.c: - code addition on one side near code change on the other side (ciphersuite validation) library/x509_crt.c -> various things - top fo file: helper structure added near old zeroize removed - documentation of find_parent_in()'s signature: improved on one side, added arguments on the other side - documentation of find_parent()'s signature: same as above - verify_chain(): variables initialised later to give compiler an opportunity to warn us if not initialised on a code path - find_parent(): funcion structure completely changed, for some reason git tried to insert a paragraph of the old structure... - merge_flags_with_cb(): data structure changed, one line was fixed with a cast to keep MSVC happy, this cast is already in the new version - in verify_restratable(): adjacent independent changes (function signature on one line, variable type on the next) programs/ssl/ssl_client2.c: - testing for IN_PROGRESS return code near idle() (event-driven): don't wait for data in the the socket if ECP_IN_PROGRESS tests/data_files/Makefile: adjacent independent additions tests/suites/test_suite_ecdsa.data: adjacent independent additions tests/suites/test_suite_x509parse.data: adjacent independent additions * development: (1059 commits) Change symlink to hardlink to avoid permission issues Fix out-of-tree testing symlinks on Windows Updated version number to 2.10.0 for release Add a disabled CMAC define in the no-entropy configuration Adapt the ARIA test cases for new ECB function Fix file permissions for ssl.h Add ChangeLog entry for PR#1651 Fix MicroBlaze register typo. Fix typo in doc and copy missing warning Fix edit mistake in cipher_wrap.c Update CTR doc for the 64-bit block cipher Update CTR doc for other 128-bit block ciphers Slightly tune ARIA CTR documentation Remove double declaration of mbedtls_ssl_list_ciphersuites Update CTR documentation Use zeroize function from new platform_util Move to new header style for ALT implementations Add ifdef for selftest in header file Fix typo in comments Use more appropriate type for local variable ...
2018-06-12 10:40:54 +00:00
* - [in-out] rs_ctx: context for restarting operations
Improve documentation of some internal functions
2018-03-07 09:00:57 +00:00
*
* Return value:
Merge branch 'development' into iotssl-1260-non-blocking-ecc-restricted Summary of merge conflicts: include/mbedtls/ecdh.h -> documentation style include/mbedtls/ecdsa.h -> documentation style include/mbedtls/ecp.h -> alt style, new error codes, documentation style include/mbedtls/error.h -> new error codes library/error.c -> new error codes (generated anyway) library/ecp.c: - code of an extracted function was changed library/ssl_cli.c: - code addition on one side near code change on the other side (ciphersuite validation) library/x509_crt.c -> various things - top fo file: helper structure added near old zeroize removed - documentation of find_parent_in()'s signature: improved on one side, added arguments on the other side - documentation of find_parent()'s signature: same as above - verify_chain(): variables initialised later to give compiler an opportunity to warn us if not initialised on a code path - find_parent(): funcion structure completely changed, for some reason git tried to insert a paragraph of the old structure... - merge_flags_with_cb(): data structure changed, one line was fixed with a cast to keep MSVC happy, this cast is already in the new version - in verify_restratable(): adjacent independent changes (function signature on one line, variable type on the next) programs/ssl/ssl_client2.c: - testing for IN_PROGRESS return code near idle() (event-driven): don't wait for data in the the socket if ECP_IN_PROGRESS tests/data_files/Makefile: adjacent independent additions tests/suites/test_suite_ecdsa.data: adjacent independent additions tests/suites/test_suite_x509parse.data: adjacent independent additions * development: (1059 commits) Change symlink to hardlink to avoid permission issues Fix out-of-tree testing symlinks on Windows Updated version number to 2.10.0 for release Add a disabled CMAC define in the no-entropy configuration Adapt the ARIA test cases for new ECB function Fix file permissions for ssl.h Add ChangeLog entry for PR#1651 Fix MicroBlaze register typo. Fix typo in doc and copy missing warning Fix edit mistake in cipher_wrap.c Update CTR doc for the 64-bit block cipher Update CTR doc for other 128-bit block ciphers Slightly tune ARIA CTR documentation Remove double declaration of mbedtls_ssl_list_ciphersuites Update CTR documentation Use zeroize function from new platform_util Move to new header style for ALT implementations Add ifdef for selftest in header file Fix typo in comments Use more appropriate type for local variable ...
2018-06-12 10:40:54 +00:00
* - 0 on success
* - MBEDTLS_ERR_ECP_IN_PROGRESS otherwise
Move code to separate function for readability
2017-07-03 23:01:39 +00:00
*/
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
static int x509_crt_find_parent(
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
mbedtls_x509_crt_sig_info const *child_sig,
Make use of CRT acquire/release for child in CRT chain verification During CRT verification, `x509_crt_check_signature()` checks whether a candidate parent CRT correctly signs the current child CRT. This commit rewrites this function to use the new acquire/release framework for using CRTs.
2019-02-25 14:58:22 +00:00
mbedtls_x509_crt *rest,
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
mbedtls_x509_crt *trust_ca,
mbedtls_x509_crt **parent,
int *parent_is_trusted,
int *signature_is_good,
Fix MSVC 64-bit warnings "conversion from size_t to int, possible loss of data"
2017-08-28 11:25:55 +00:00
unsigned path_cnt,
unsigned self_cnt,
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
mbedtls_x509_crt_restart_ctx *rs_ctx )
Move code to separate function for readability
2017-07-03 23:01:39 +00:00
{
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
int ret;
Refactor find_parent() to merge two call sites
2017-08-14 14:11:43 +00:00
mbedtls_x509_crt *search_list;
Move code to separate function for readability
2017-07-03 23:01:39 +00:00
*parent_is_trusted = 1;
Refactor find_parent() to merge two call sites
2017-08-14 14:11:43 +00:00
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Clarify state handling in find_parent(_in)()
2017-08-23 09:20:48 +00:00
/* restore then clear saved state if we have some stored */
if( rs_ctx != NULL && rs_ctx->parent_is_trusted != -1 )
{
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
*parent_is_trusted = rs_ctx->parent_is_trusted;
Clarify state handling in find_parent(_in)()
2017-08-23 09:20:48 +00:00
rs_ctx->parent_is_trusted = -1;
}
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
#endif
Refactor find_parent() to merge two call sites
2017-08-14 14:11:43 +00:00
while( 1 ) {
Make use of CRT acquire/release for child in CRT chain verification During CRT verification, `x509_crt_check_signature()` checks whether a candidate parent CRT correctly signs the current child CRT. This commit rewrites this function to use the new acquire/release framework for using CRTs.
2019-02-25 14:58:22 +00:00
search_list = *parent_is_trusted ? trust_ca : rest;
Refactor find_parent() to merge two call sites
2017-08-14 14:11:43 +00:00
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
ret = x509_crt_find_parent_in( child_sig, search_list,
Refactor find_parent() to merge two call sites
2017-08-14 14:11:43 +00:00
parent, signature_is_good,
*parent_is_trusted,
path_cnt, self_cnt, rs_ctx );
Move code to separate function for readability
2017-07-03 23:01:39 +00:00
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
if( rs_ctx != NULL && ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
{
/* save state */
rs_ctx->parent_is_trusted = *parent_is_trusted;
Refactor find_parent() to merge two call sites
2017-08-14 14:11:43 +00:00
return( ret );
}
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
#else
(void) ret;
#endif
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
Refactor find_parent() to merge two call sites
2017-08-14 14:11:43 +00:00
/* stop here if found or already in second iteration */
if( *parent != NULL || *parent_is_trusted == 0 )
break;
Move code to separate function for readability
2017-07-03 23:01:39 +00:00
Refactor find_parent() to merge two call sites
2017-08-14 14:11:43 +00:00
/* prepare second iteration */
*parent_is_trusted = 0;
}
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
Refactor find_parent() to merge two call sites
2017-08-14 14:11:43 +00:00
/* extra precaution against mistakes in the caller */
Fix typo in a test condition code
2018-10-31 15:49:20 +00:00
if( *parent == NULL )
Refactor find_parent() to merge two call sites
2017-08-14 14:11:43 +00:00
{
Fix missing dereference. Went unnoticed because it was only on a defensive code path, in an internal function, so not exercised.
2018-10-16 09:27:23 +00:00
*parent_is_trusted = 0;
*signature_is_good = 0;
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
}
return( 0 );
Move code to separate function for readability
2017-07-03 23:01:39 +00:00
}
Simplify handling of locally trusted EE certs Though this might require one more walk of the list in some cases, this avoid having a check for that deep inside check_parent().
2017-07-03 22:49:31 +00:00
/*
* Check if an end-entity certificate is locally trusted
*
* Currently we require such certificates to be self-signed (actually only
* check for self-issued as self-signatures are not checked)
*/
static int x509_crt_check_ee_locally_trusted(
Make use of CRT acquire/release for child in CRT chain verification During CRT verification, `x509_crt_check_signature()` checks whether a candidate parent CRT correctly signs the current child CRT. This commit rewrites this function to use the new acquire/release framework for using CRTs.
2019-02-25 14:58:22 +00:00
mbedtls_x509_crt_frame const *crt,
mbedtls_x509_crt const *trust_ca )
Simplify handling of locally trusted EE certs Though this might require one more walk of the list in some cases, this avoid having a check for that deep inside check_parent().
2017-07-03 22:49:31 +00:00
{
Make use of CRT acquire/release for child in CRT chain verification During CRT verification, `x509_crt_check_signature()` checks whether a candidate parent CRT correctly signs the current child CRT. This commit rewrites this function to use the new acquire/release framework for using CRTs.
2019-02-25 14:58:22 +00:00
mbedtls_x509_crt const *cur;
Simplify handling of locally trusted EE certs Though this might require one more walk of the list in some cases, this avoid having a check for that deep inside check_parent().
2017-07-03 22:49:31 +00:00
/* look for an exact match with trusted cert */
for( cur = trust_ca; cur != NULL; cur = cur->next )
{
if( crt->raw.len == cur->raw.len &&
memcmp( crt->raw.p, cur->raw.p, crt->raw.len ) == 0 )
{
return( 0 );
}
}
/* too bad */
return( -1 );
}
Add comments on chain verification cases This is the beginning of a series of commits refactoring the chain building/verification functions in order to: - make it simpler to understand and work with - prepare integration of restartable ECC
2017-06-29 08:45:25 +00:00
/*
Rm unneeded function arguments & update comments
2017-07-05 14:43:44 +00:00
* Build and verify a certificate chain
Add comments on chain verification cases This is the beginning of a series of commits refactoring the chain building/verification functions in order to: - make it simpler to understand and work with - prepare integration of restartable ECC
2017-06-29 08:45:25 +00:00
*
Rm unneeded function arguments & update comments
2017-07-05 14:43:44 +00:00
* Given a peer-provided list of certificates EE, C1, ..., Cn and
* a list of trusted certs R1, ... Rp, try to build and verify a chain
Improve some comments, fix some typos+whitespace
2017-08-08 16:09:14 +00:00
* EE, Ci1, ... Ciq [, Rj]
Rm unneeded function arguments & update comments
2017-07-05 14:43:44 +00:00
* such that every cert in the chain is a child of the next one,
* jumping to a trusted root as early as possible.
Update comments
2017-07-03 22:33:39 +00:00
*
Rm unneeded function arguments & update comments
2017-07-05 14:43:44 +00:00
* Verify that chain and return it with flags for all issues found.
*
* Special cases:
* - EE == Rj -> return a one-element list containing it
* - EE, Ci1, ..., Ciq cannot be continued with a trusted root
* -> return that chain with NOT_TRUSTED set on Ciq
Update comments
2017-07-03 22:33:39 +00:00
*
Add tests for verify_restartable() For selection of test cases, see comments added in the commit. It makes the most sense to test with chains using ECC only, so for the chain of length 2 we use server10 -> int-ca3 -> int-ca2 and trust int-ca2 directly. Note: server10.crt was created by copying server10_int3_int-ca2.crt and manually truncating it to remove the intermediates. That base can now be used to create derived certs (without or with a chain) in a programmatic way.
2017-07-14 09:05:59 +00:00
* Tests for (aspects of) this function should include at least:
* - trusted EE
* - EE -> trusted root
* - EE -> intermedate CA -> trusted root
* - if relevant: EE untrusted
* - if relevant: EE -> intermediate, untrusted
* with the aspect under test checked at each relevant level (EE, int, root).
* For some aspects longer chains are required, but usually length 2 is
* enough (but length 1 is not in general).
*
Update comments
2017-07-03 22:33:39 +00:00
* Arguments:
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
* - [in] crt: the cert list EE, C1, ..., Cn
* - [in] trust_ca: the trusted list R1, ..., Rp
* - [in] ca_crl, profile: as in verify_with_profile()
Rework type for verify chain - create container with length + table - make types public (will be needed in restart context)
2017-08-14 15:17:14 +00:00
* - [out] ver_chain: the built and verified chain
Improve some comments in verify_chain()
2017-08-23 09:23:59 +00:00
* Only valid when return value is 0, may contain garbage otherwise!
* Restart note: need not be the same when calling again to resume.
Better document some function arguments
2017-08-17 08:52:20 +00:00
* - [in-out] rs_ctx: context for restarting operations
Rm unneeded function arguments & update comments
2017-07-05 14:43:44 +00:00
*
* Return value:
* - non-zero if the chain could not be fully built and examined
* - 0 is the chain was successfully built and examined,
* even if it was found to be invalid
Add comments on chain verification cases This is the beginning of a series of commits refactoring the chain building/verification functions in order to: - make it simpler to understand and work with - prepare integration of restartable ECC
2017-06-29 08:45:25 +00:00
*/
Update comments
2017-07-03 22:33:39 +00:00
static int x509_crt_verify_chain(
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
mbedtls_x509_crt *crt,
mbedtls_x509_crt *trust_ca,
mbedtls_x509_crl *ca_crl,
Create cert profile API (unimplemented yet)
2015-06-15 08:39:46 +00:00
const mbedtls_x509_crt_profile *profile,
Rework type for verify chain - create container with length + table - make types public (will be needed in restart context)
2017-08-14 15:17:14 +00:00
mbedtls_x509_crt_verify_chain *ver_chain,
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
mbedtls_x509_crt_restart_ctx *rs_ctx )
- Revamped x509_verify() and the SSL f_vrfy callback implementations
2012-09-28 07:10:55 +00:00
{
Improve some comments in verify_chain()
2017-08-23 09:23:59 +00:00
/* Don't initialize any of those variables here, so that the compiler can
* catch potential issues with jumping ahead when restarting */
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
int ret;
Rm unneeded function arguments & update comments
2017-07-05 14:43:44 +00:00
uint32_t *flags;
Rework type for verify chain - create container with length + table - make types public (will be needed in restart context)
2017-08-14 15:17:14 +00:00
mbedtls_x509_crt_verify_chain_item *cur;
Make use of CRT acquire/release for child in CRT chain verification During CRT verification, `x509_crt_check_signature()` checks whether a candidate parent CRT correctly signs the current child CRT. This commit rewrites this function to use the new acquire/release framework for using CRTs.
2019-02-25 14:58:22 +00:00
mbedtls_x509_crt *child_crt;
Make use of CRT acquire/release in CRT chain verification #2
2019-02-25 18:13:46 +00:00
mbedtls_x509_crt *parent_crt;
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
int parent_is_trusted;
int child_is_trusted;
int signature_is_good;
Fix MSVC 64-bit warnings "conversion from size_t to int, possible loss of data"
2017-08-28 11:25:55 +00:00
unsigned self_cnt;
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
/* resume if we had an operation in progress */
Rework state saving for verify_chain() Child was almost redundant as it's already saved in ver_chain, except it was multiplexed to also indicate whether an operation is in progress. This commit removes it and introduces an explicit state variable instead. This state can be useful later if we start returning IN_PROGRESS at other points than find_parent() (for example when checking CRL). Note that the state goes none -> find_parent and stays there until the context is free(), as it's only on the first call that nothing was in progress.
2017-08-23 10:32:19 +00:00
if( rs_ctx != NULL && rs_ctx->in_progress == x509_crt_rs_find_parent )
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
{
Clarify state handling in find_parent(_in)()
2017-08-23 09:20:48 +00:00
/* restore saved state */
Improve some comments in verify_chain()
2017-08-23 09:23:59 +00:00
*ver_chain = rs_ctx->ver_chain; /* struct copy */
Rework state saving for verify_chain() Child was almost redundant as it's already saved in ver_chain, except it was multiplexed to also indicate whether an operation is in progress. This commit removes it and introduces an explicit state variable instead. This state can be useful later if we start returning IN_PROGRESS at other points than find_parent() (for example when checking CRL). Note that the state goes none -> find_parent and stays there until the context is free(), as it's only on the first call that nothing was in progress.
2017-08-23 10:32:19 +00:00
self_cnt = rs_ctx->self_cnt;
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
Rework state saving for verify_chain() Child was almost redundant as it's already saved in ver_chain, except it was multiplexed to also indicate whether an operation is in progress. This commit removes it and introduces an explicit state variable instead. This state can be useful later if we start returning IN_PROGRESS at other points than find_parent() (for example when checking CRL). Note that the state goes none -> find_parent and stays there until the context is free(), as it's only on the first call that nothing was in progress.
2017-08-23 10:32:19 +00:00
/* restore derived state */
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
cur = &ver_chain->items[ver_chain->len - 1];
Make use of CRT acquire/release for child in CRT chain verification During CRT verification, `x509_crt_check_signature()` checks whether a candidate parent CRT correctly signs the current child CRT. This commit rewrites this function to use the new acquire/release framework for using CRTs.
2019-02-25 14:58:22 +00:00
child_crt = cur->crt;
child_is_trusted = 0;
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
goto find_parent;
}
#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
Merge near-duplicated (grand)parent finding code Besides avoiding near-duplication, this avoids having three generations of certificate (child, parent, grandparent) in one function, with all the off-by-one opportunities that come with it. This also allows to simplify the signature of verify_child(), which will be done in next commit.
2017-07-03 19:25:10 +00:00
Make use of CRT acquire/release for child in CRT chain verification During CRT verification, `x509_crt_check_signature()` checks whether a candidate parent CRT correctly signs the current child CRT. This commit rewrites this function to use the new acquire/release framework for using CRTs.
2019-02-25 14:58:22 +00:00
child_crt = crt;
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
self_cnt = 0;
parent_is_trusted = 0;
child_is_trusted = 0;
Rm unneeded function arguments & update comments
2017-07-05 14:43:44 +00:00
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
while( 1 ) {
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
#if defined(MBEDTLS_X509_CRL_PARSE_C)
mbedtls_x509_buf_raw child_serial;
#endif /* MBEDTLS_X509_CRL_PARSE_C */
int self_issued;
Make use of CRT acquire/release for child in CRT chain verification During CRT verification, `x509_crt_check_signature()` checks whether a candidate parent CRT correctly signs the current child CRT. This commit rewrites this function to use the new acquire/release framework for using CRTs.
2019-02-25 14:58:22 +00:00
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
/* Add certificate to the verification chain */
Rework type for verify chain - create container with length + table - make types public (will be needed in restart context)
2017-08-14 15:17:14 +00:00
cur = &ver_chain->items[ver_chain->len];
Make use of CRT acquire/release for child in CRT chain verification During CRT verification, `x509_crt_check_signature()` checks whether a candidate parent CRT correctly signs the current child CRT. This commit rewrites this function to use the new acquire/release framework for using CRTs.
2019-02-25 14:58:22 +00:00
cur->crt = child_crt;
Better initialisation of ver_chain Use dedicated function for consistency, and initialise flags to -1 as this is the safe value.
2017-08-23 08:55:41 +00:00
cur->flags = 0;
Rework type for verify chain - create container with length + table - make types public (will be needed in restart context)
2017-08-14 15:17:14 +00:00
ver_chain->len++;
Move point of re-entry for restartable X.509 verification
2019-02-22 17:56:43 +00:00
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
find_parent:
#endif
Better initialisation of ver_chain Use dedicated function for consistency, and initialise flags to -1 as this is the safe value.
2017-08-23 08:55:41 +00:00
flags = &cur->flags;
Merge duplicated checks between child() and top()
2017-07-03 19:39:21 +00:00
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
{
mbedtls_x509_crt_sig_info child_sig;
{
Don't allow change of CRT frame returned by x509_crt_frame_acquire()
2019-05-20 15:26:34 +00:00
mbedtls_x509_crt_frame const *child;
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
ret = mbedtls_x509_crt_frame_acquire( child_crt, &child );
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
if( ret != 0 )
return( MBEDTLS_ERR_X509_FATAL_ERROR );
/* Check time-validity (all certificates) */
if( mbedtls_x509_time_is_past( &child->valid_to ) )
*flags |= MBEDTLS_X509_BADCERT_EXPIRED;
if( mbedtls_x509_time_is_future( &child->valid_from ) )
*flags |= MBEDTLS_X509_BADCERT_FUTURE;
/* Stop here for trusted roots (but not for trusted EE certs) */
if( child_is_trusted )
{
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_frame_release( child_crt );
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
return( 0 );
}
self_issued = 0;
if( mbedtls_x509_name_cmp_raw( &child->issuer_raw,
&child->subject_raw,
NULL, NULL ) == 0 )
{
self_issued = 1;
}
/* Check signature algorithm: MD & PK algs */
if( x509_profile_check_md_alg( profile, child->sig_md ) != 0 )
*flags |= MBEDTLS_X509_BADCERT_BAD_MD;
if( x509_profile_check_pk_alg( profile, child->sig_pk ) != 0 )
*flags |= MBEDTLS_X509_BADCERT_BAD_PK;
/* Special case: EE certs that are locally trusted */
if( ver_chain->len == 1 && self_issued &&
x509_crt_check_ee_locally_trusted( child, trust_ca ) == 0 )
{
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_frame_release( child_crt );
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
return( 0 );
}
Merge duplicated checks between child() and top()
2017-07-03 19:39:21 +00:00
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
#if defined(MBEDTLS_X509_CRL_PARSE_C)
child_serial = child->serial;
#endif /* MBEDTLS_X509_CRL_PARSE_C */
Finally merge the remains of top() into child()
2017-07-03 22:00:24 +00:00
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
ret = x509_crt_get_sig_info( child, &child_sig );
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_frame_release( child_crt );
Merge duplicated checks between child() and top()
2017-07-03 19:39:21 +00:00
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
if( ret != 0 )
return( MBEDTLS_ERR_X509_FATAL_ERROR );
}
Merge duplicated checks between child() and top()
2017-07-03 19:39:21 +00:00
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
/* Look for a parent in trusted CAs or up the chain */
ret = x509_crt_find_parent( &child_sig, child_crt->next,
Make use of CRT acquire/release in CRT chain verification #2
2019-02-25 18:13:46 +00:00
trust_ca, &parent_crt,
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
&parent_is_trusted, &signature_is_good,
ver_chain->len - 1, self_cnt, rs_ctx );
Simplify handling of locally trusted EE certs Though this might require one more walk of the list in some cases, this avoid having a check for that deep inside check_parent().
2017-07-03 22:49:31 +00:00
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
x509_crt_free_sig_info( &child_sig );
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
}
Merge near-duplicated (grand)parent finding code Besides avoiding near-duplication, this avoids having three generations of certificate (child, parent, grandparent) in one function, with all the off-by-one opportunities that come with it. This also allows to simplify the signature of verify_child(), which will be done in next commit.
2017-07-03 19:25:10 +00:00
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
if( rs_ctx != NULL && ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
{
/* save state */
Rework state saving for verify_chain() Child was almost redundant as it's already saved in ver_chain, except it was multiplexed to also indicate whether an operation is in progress. This commit removes it and introduces an explicit state variable instead. This state can be useful later if we start returning IN_PROGRESS at other points than find_parent() (for example when checking CRL). Note that the state goes none -> find_parent and stays there until the context is free(), as it's only on the first call that nothing was in progress.
2017-08-23 10:32:19 +00:00
rs_ctx->in_progress = x509_crt_rs_find_parent;
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
rs_ctx->self_cnt = self_cnt;
Improve some comments in verify_chain()
2017-08-23 09:23:59 +00:00
rs_ctx->ver_chain = *ver_chain; /* struct copy */
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
return( ret );
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
}
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
#else
(void) ret;
#endif
- Revamped x509_verify() and the SSL f_vrfy callback implementations
2012-09-28 07:10:55 +00:00
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
/* No parent? We're done here */
Make use of CRT acquire/release in CRT chain verification #2
2019-02-25 18:13:46 +00:00
if( parent_crt == NULL )
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
{
*flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
return( 0 );
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
}
- Revamped x509_verify() and the SSL f_vrfy callback implementations
2012-09-28 07:10:55 +00:00
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
/* Count intermediate self-issued (not necessarily self-signed) certs.
* These can occur with some strategies for key rollover, see [SIRO],
* and should be excluded from max_pathlen checks. */
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
if( ver_chain->len != 1 && self_issued )
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
self_cnt++;
Set a compile-time limit to X.509 chain length
2014-11-20 15:34:20 +00:00
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
/* path_cnt is 0 for the first intermediate CA,
* and if parent is trusted it's not an intermediate CA */
if( ! parent_is_trusted &&
Rework type for verify chain - create container with length + table - make types public (will be needed in restart context)
2017-08-14 15:17:14 +00:00
ver_chain->len > MBEDTLS_X509_MAX_INTERMEDIATE_CA )
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
{
/* return immediately to avoid overflow the chain array */
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
return( MBEDTLS_ERR_X509_FATAL_ERROR );
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
}
Better document some function arguments
2017-08-17 08:52:20 +00:00
/* signature was checked while searching parent */
Call crt_check_signature from one place only
2017-07-14 10:04:14 +00:00
if( ! signature_is_good )
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
*flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
- Revamped x509_verify() and the SSL f_vrfy callback implementations
2012-09-28 07:10:55 +00:00
Make use of CRT acquire/release in CRT chain verification #2
2019-02-25 18:13:46 +00:00
{
mbedtls_pk_context *parent_pk;
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
ret = mbedtls_x509_crt_pk_acquire( parent_crt, &parent_pk );
Make use of CRT acquire/release in CRT chain verification #2
2019-02-25 18:13:46 +00:00
if( ret != 0 )
return( MBEDTLS_ERR_X509_FATAL_ERROR );
/* check size of signing key */
if( x509_profile_check_key( profile, parent_pk ) != 0 )
*flags |= MBEDTLS_X509_BADCERT_BAD_KEY;
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_pk_release( parent_crt );
Make use of CRT acquire/release in CRT chain verification #2
2019-02-25 18:13:46 +00:00
}
- Revamped x509_verify() and the SSL f_vrfy callback implementations
2012-09-28 07:10:55 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_X509_CRL_PARSE_C)
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
/* Check trusted CA's CRL for the given crt */
Add structure holding X.509 CRT signature information This commit introduces an internal structure `mbedtls_x509_crt_sig_info` containing all information that has to be kept from a child CRT when searching for a potential parent: - The issuer name - The signature type - The signature - The hash of the CRT The structure can be obtained from a CRT frame via `x509_crt_get_sig_info()` and freed via `x509_crt_free_sig_info()`. The purpose of this is to reduce the amount of RAM used during CRT chain verification; once we've extracted the signature info structure from the current child CRT, we can free all cached data for that CRT (frame and PK) before searching for a suitable parent. This way, there will ultimately not be more than one frame needed at a single point during the verification.
2019-02-25 13:50:41 +00:00
*flags |= x509_crt_verifycrl( child_serial.p,
child_serial.len,
Make use of CRT acquire/release in CRT chain verification #2
2019-02-25 18:13:46 +00:00
parent_crt, ca_crl, profile );
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
#else
(void) ca_crl;
Split up X509 files into smaller modules
2013-09-16 11:49:26 +00:00
#endif
- Revamped x509_verify() and the SSL f_vrfy callback implementations
2012-09-28 07:10:55 +00:00
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
/* prepare for next iteration */
Make use of CRT acquire/release in CRT chain verification #2
2019-02-25 18:13:46 +00:00
child_crt = parent_crt;
parent_crt = NULL;
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
child_is_trusted = parent_is_trusted;
Call crt_check_signature from one place only
2017-07-14 10:04:14 +00:00
signature_is_good = 0;
Make verify_chain() iterative
2017-07-05 15:05:03 +00:00
}
- Revamped x509_verify() and the SSL f_vrfy callback implementations
2012-09-28 07:10:55 +00:00
}
verify_name(): factor duplicated code to function
2017-07-03 23:31:59 +00:00
/*
* Check for CN match
*/
Pass raw data to x509_check_wildcard() and `x509_crt_check_cn()` In preparation for rewriting the `SubjectAlternativeName` search routine to use raw ASN.1 data, this commit changes `x509_check_wildcard()` and `x509_check_cn()`, responsible for checking whether a name matches a wildcard pattern, to take a raw buffer pointer and length as parameters instead of an `mbedtls_x509_buf` instance.
2019-02-21 13:10:55 +00:00
static int x509_crt_check_cn( unsigned char const *buf,
size_t buflen,
const char *cn,
size_t cn_len )
verify_name(): factor duplicated code to function
2017-07-03 23:31:59 +00:00
{
Pass raw data to x509_check_wildcard() and `x509_crt_check_cn()` In preparation for rewriting the `SubjectAlternativeName` search routine to use raw ASN.1 data, this commit changes `x509_check_wildcard()` and `x509_check_cn()`, responsible for checking whether a name matches a wildcard pattern, to take a raw buffer pointer and length as parameters instead of an `mbedtls_x509_buf` instance.
2019-02-21 13:10:55 +00:00
/* Try exact match */
Move length check into mbedtls_x509_memcasecmp() At every occasion where we're using `mbedtls_x509_memcasecmp()` we're checking that the two buffer lengths coincide before making the call. This commit saves a few bytes of code by moving this length check to `mbedtls_x509_memcasecmp()`.
2019-02-22 11:46:06 +00:00
if( mbedtls_x509_memcasecmp( cn, buf, buflen, cn_len ) == 0 )
verify_name(): factor duplicated code to function
2017-07-03 23:31:59 +00:00
return( 0 );
/* try wildcard match */
Pass raw data to x509_check_wildcard() and `x509_crt_check_cn()` In preparation for rewriting the `SubjectAlternativeName` search routine to use raw ASN.1 data, this commit changes `x509_check_wildcard()` and `x509_check_cn()`, responsible for checking whether a name matches a wildcard pattern, to take a raw buffer pointer and length as parameters instead of an `mbedtls_x509_buf` instance.
2019-02-21 13:10:55 +00:00
if( x509_check_wildcard( cn, cn_len, buf, buflen ) == 0 )
verify_name(): factor duplicated code to function
2017-07-03 23:31:59 +00:00
{
return( 0 );
}
return( -1 );
}
Make use of abort condition callback in CN comparison The previous CN name comparison function x509_crt_verify_name() traversed the dynamically allocated linked list presentation of the CRT's subject, comparing each entry to the desired hostname configured by the application code. Eventually, we want to get rid of the linked list presentation of the CRT's subject to save both code and RAM usage, and hence need to rewrite the CN verification routine in a way that builds on the raw ASN.1 subject data only. In order to avoid duplicating the code for the parsing of the nested ASN.1 name structure, this commit performs the name search by using the existing name traversal function mbedtls_x509_name_cmp_raw(), passing to it a callback which checks whether the current name component matches the desired hostname.
2019-02-21 11:50:44 +00:00
/* Returns 1 on a match and 0 on a mismatch.
* This is because this function is used as a callback for
* mbedtls_x509_name_cmp_raw(), which continues the name
* traversal as long as the callback returns 0. */
static int x509_crt_check_name( void *ctx,
mbedtls_x509_buf *oid,
Add `next_merged` field to X.509 name comparison abort callback
2019-02-23 10:20:14 +00:00
mbedtls_x509_buf *val,
int next_merged )
Make use of abort condition callback in CN comparison The previous CN name comparison function x509_crt_verify_name() traversed the dynamically allocated linked list presentation of the CRT's subject, comparing each entry to the desired hostname configured by the application code. Eventually, we want to get rid of the linked list presentation of the CRT's subject to save both code and RAM usage, and hence need to rewrite the CN verification routine in a way that builds on the raw ASN.1 subject data only. In order to avoid duplicating the code for the parsing of the nested ASN.1 name structure, this commit performs the name search by using the existing name traversal function mbedtls_x509_name_cmp_raw(), passing to it a callback which checks whether the current name component matches the desired hostname.
2019-02-21 11:50:44 +00:00
{
char const *cn = (char const*) ctx;
size_t cn_len = strlen( cn );
Add `next_merged` field to X.509 name comparison abort callback
2019-02-23 10:20:14 +00:00
((void) next_merged);
Make use of abort condition callback in CN comparison The previous CN name comparison function x509_crt_verify_name() traversed the dynamically allocated linked list presentation of the CRT's subject, comparing each entry to the desired hostname configured by the application code. Eventually, we want to get rid of the linked list presentation of the CRT's subject to save both code and RAM usage, and hence need to rewrite the CN verification routine in a way that builds on the raw ASN.1 subject data only. In order to avoid duplicating the code for the parsing of the nested ASN.1 name structure, this commit performs the name search by using the existing name traversal function mbedtls_x509_name_cmp_raw(), passing to it a callback which checks whether the current name component matches the desired hostname.
2019-02-21 11:50:44 +00:00
if( MBEDTLS_OID_CMP( MBEDTLS_OID_AT_CN, oid ) == 0 &&
Pass raw data to x509_check_wildcard() and `x509_crt_check_cn()` In preparation for rewriting the `SubjectAlternativeName` search routine to use raw ASN.1 data, this commit changes `x509_check_wildcard()` and `x509_check_cn()`, responsible for checking whether a name matches a wildcard pattern, to take a raw buffer pointer and length as parameters instead of an `mbedtls_x509_buf` instance.
2019-02-21 13:10:55 +00:00
x509_crt_check_cn( val->p, val->len, cn, cn_len ) == 0 )
Make use of abort condition callback in CN comparison The previous CN name comparison function x509_crt_verify_name() traversed the dynamically allocated linked list presentation of the CRT's subject, comparing each entry to the desired hostname configured by the application code. Eventually, we want to get rid of the linked list presentation of the CRT's subject to save both code and RAM usage, and hence need to rewrite the CN verification routine in a way that builds on the raw ASN.1 subject data only. In order to avoid duplicating the code for the parsing of the nested ASN.1 name structure, this commit performs the name search by using the existing name traversal function mbedtls_x509_name_cmp_raw(), passing to it a callback which checks whether the current name component matches the desired hostname.
2019-02-21 11:50:44 +00:00
{
return( 1 );
}
return( 0 );
}
Add callback to search through SubjectAltNames extension The current CN name verification x509_crt_verify_name() traverses the dynamically allocated linked list presentation of the subject alternative name extension, searching for an alternative name that matches the desired hostname configured by the application. Eventually, we want to remove this dynamically allocated linked list for the benefit of reduced code size and RAM usage, and hence need to rewrite x509_crt_verify_name() in a way that builds on the raw ASN.1 buffer holding the SubjectAlternativeNames extension. This commit does this by using the existing SubjectAlternativeNames traversal routine x509_subject_alt_name_traverse(), passing to it a callback which compares the current alternative name component to the desired hostname configured by the application.
2019-02-21 13:36:59 +00:00
/* Returns 1 on a match and 0 on a mismatch.
* This is because this function is used as a callback for
* mbedtls_asn1_traverse_sequence_of(), which continues the
* traversal as long as the callback returns 0. */
static int x509_crt_subject_alt_check_name( void *ctx,
int tag,
unsigned char *data,
size_t data_len )
{
char const *cn = (char const*) ctx;
size_t cn_len = strlen( cn );
Implement SubjectAltName traversal via ASN.1 SEQUENCE OF traversal This commit re-implements the `SubjectAlternativeName` traversal routine in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-21 21:13:21 +00:00
((void) tag);
Add callback to search through SubjectAltNames extension The current CN name verification x509_crt_verify_name() traverses the dynamically allocated linked list presentation of the subject alternative name extension, searching for an alternative name that matches the desired hostname configured by the application. Eventually, we want to remove this dynamically allocated linked list for the benefit of reduced code size and RAM usage, and hence need to rewrite x509_crt_verify_name() in a way that builds on the raw ASN.1 buffer holding the SubjectAlternativeNames extension. This commit does this by using the existing SubjectAlternativeNames traversal routine x509_subject_alt_name_traverse(), passing to it a callback which compares the current alternative name component to the desired hostname configured by the application.
2019-02-21 13:36:59 +00:00
if( x509_crt_check_cn( data, data_len, cn, cn_len ) == 0 )
return( 1 );
return( 0 );
}
Extract name checking to separate function Just copy-paste and unindent
2017-07-03 23:13:44 +00:00
/*
* Verify the requested CN - only call this if cn is not NULL!
*/
Make use of CRT acquire/release in x509_crt_verify_name() This commit modifies the static function `x509_crt_verify_name()` to use the acquire/release API to access the given CRTs `subject` field. This function is solely called from the beginning of the CRT chain verification routine, which also needs to access the child's CRT frame. It should therefore be considered - for a later commit - to collapse the two acquire/release pairs to one, thereby saving some code.
2019-02-25 18:14:40 +00:00
static int x509_crt_verify_name( const mbedtls_x509_crt *crt,
const char *cn,
uint32_t *flags )
Extract name checking to separate function Just copy-paste and unindent
2017-07-03 23:13:44 +00:00
{
Add callback to search through SubjectAltNames extension The current CN name verification x509_crt_verify_name() traverses the dynamically allocated linked list presentation of the subject alternative name extension, searching for an alternative name that matches the desired hostname configured by the application. Eventually, we want to remove this dynamically allocated linked list for the benefit of reduced code size and RAM usage, and hence need to rewrite x509_crt_verify_name() in a way that builds on the raw ASN.1 buffer holding the SubjectAlternativeNames extension. This commit does this by using the existing SubjectAlternativeNames traversal routine x509_subject_alt_name_traverse(), passing to it a callback which compares the current alternative name component to the desired hostname configured by the application.
2019-02-21 13:36:59 +00:00
int ret;
Don't allow change of CRT frame returned by x509_crt_frame_acquire()
2019-05-20 15:26:34 +00:00
mbedtls_x509_crt_frame const *frame;
Extract name checking to separate function Just copy-paste and unindent
2017-07-03 23:13:44 +00:00
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
Make use of CRT acquire/release in x509_crt_verify_name() This commit modifies the static function `x509_crt_verify_name()` to use the acquire/release API to access the given CRTs `subject` field. This function is solely called from the beginning of the CRT chain verification routine, which also needs to access the child's CRT frame. It should therefore be considered - for a later commit - to collapse the two acquire/release pairs to one, thereby saving some code.
2019-02-25 18:14:40 +00:00
if( ret != 0 )
return( MBEDTLS_ERR_X509_FATAL_ERROR );
if( frame->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME )
Extract name checking to separate function Just copy-paste and unindent
2017-07-03 23:13:44 +00:00
{
Implement SubjectAltName traversal via ASN.1 SEQUENCE OF traversal This commit re-implements the `SubjectAlternativeName` traversal routine in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-21 21:13:21 +00:00
unsigned char *p =
Make use of CRT acquire/release in x509_crt_verify_name() This commit modifies the static function `x509_crt_verify_name()` to use the acquire/release API to access the given CRTs `subject` field. This function is solely called from the beginning of the CRT chain verification routine, which also needs to access the child's CRT frame. It should therefore be considered - for a later commit - to collapse the two acquire/release pairs to one, thereby saving some code.
2019-02-25 18:14:40 +00:00
frame->subject_alt_raw.p;
Add callback to search through SubjectAltNames extension The current CN name verification x509_crt_verify_name() traverses the dynamically allocated linked list presentation of the subject alternative name extension, searching for an alternative name that matches the desired hostname configured by the application. Eventually, we want to remove this dynamically allocated linked list for the benefit of reduced code size and RAM usage, and hence need to rewrite x509_crt_verify_name() in a way that builds on the raw ASN.1 buffer holding the SubjectAlternativeNames extension. This commit does this by using the existing SubjectAlternativeNames traversal routine x509_subject_alt_name_traverse(), passing to it a callback which compares the current alternative name component to the desired hostname configured by the application.
2019-02-21 13:36:59 +00:00
const unsigned char *end =
Make use of CRT acquire/release in x509_crt_verify_name() This commit modifies the static function `x509_crt_verify_name()` to use the acquire/release API to access the given CRTs `subject` field. This function is solely called from the beginning of the CRT chain verification routine, which also needs to access the child's CRT frame. It should therefore be considered - for a later commit - to collapse the two acquire/release pairs to one, thereby saving some code.
2019-02-25 18:14:40 +00:00
frame->subject_alt_raw.p + frame->subject_alt_raw.len;
Extract name checking to separate function Just copy-paste and unindent
2017-07-03 23:13:44 +00:00
Implement SubjectAltName traversal via ASN.1 SEQUENCE OF traversal This commit re-implements the `SubjectAlternativeName` traversal routine in terms of the generic ASN.1 SEQUENCE traversal routine.
2019-02-21 21:13:21 +00:00
ret = mbedtls_asn1_traverse_sequence_of( &p, end,
MBEDTLS_ASN1_TAG_CLASS_MASK,
MBEDTLS_ASN1_CONTEXT_SPECIFIC,
MBEDTLS_ASN1_TAG_VALUE_MASK,
2 /* SubjectAlt DNS */,
x509_crt_subject_alt_check_name,
Consistently use (type *) instead of (type*) for pointer conversion
2019-05-29 13:41:44 +00:00
(void *) cn );
Extract name checking to separate function Just copy-paste and unindent
2017-07-03 23:13:44 +00:00
}
else
{
Make use of CRT acquire/release in x509_crt_verify_name() This commit modifies the static function `x509_crt_verify_name()` to use the acquire/release API to access the given CRTs `subject` field. This function is solely called from the beginning of the CRT chain verification routine, which also needs to access the child's CRT frame. It should therefore be considered - for a later commit - to collapse the two acquire/release pairs to one, thereby saving some code.
2019-02-25 18:14:40 +00:00
ret = mbedtls_x509_name_cmp_raw( &frame->subject_raw,
&frame->subject_raw,
Consistently use (type *) instead of (type*) for pointer conversion
2019-05-29 13:41:44 +00:00
x509_crt_check_name, (void *) cn );
Extract name checking to separate function Just copy-paste and unindent
2017-07-03 23:13:44 +00:00
}
Add callback to search through SubjectAltNames extension The current CN name verification x509_crt_verify_name() traverses the dynamically allocated linked list presentation of the subject alternative name extension, searching for an alternative name that matches the desired hostname configured by the application. Eventually, we want to remove this dynamically allocated linked list for the benefit of reduced code size and RAM usage, and hence need to rewrite x509_crt_verify_name() in a way that builds on the raw ASN.1 buffer holding the SubjectAlternativeNames extension. This commit does this by using the existing SubjectAlternativeNames traversal routine x509_subject_alt_name_traverse(), passing to it a callback which compares the current alternative name component to the desired hostname configured by the application.
2019-02-21 13:36:59 +00:00
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_frame_release( crt );
Make use of CRT acquire/release in x509_crt_verify_name() This commit modifies the static function `x509_crt_verify_name()` to use the acquire/release API to access the given CRTs `subject` field. This function is solely called from the beginning of the CRT chain verification routine, which also needs to access the child's CRT frame. It should therefore be considered - for a later commit - to collapse the two acquire/release pairs to one, thereby saving some code.
2019-02-25 18:14:40 +00:00
/* x509_crt_check_name() and x509_crt_subject_alt_check_name()
* return 1 when finding a name component matching `cn`. */
if( ret == 1 )
return( 0 );
if( ret != 0 )
ret = MBEDTLS_ERR_X509_FATAL_ERROR;
*flags |= MBEDTLS_X509_BADCERT_CN_MISMATCH;
return( ret );
Extract name checking to separate function Just copy-paste and unindent
2017-07-03 23:13:44 +00:00
}
Extract code to separate function for readablity
2017-07-05 15:18:42 +00:00
/*
* Merge the flags for all certs in the chain, after calling callback
*/
static int x509_crt_merge_flags_with_cb(
uint32_t *flags,
Rework type for verify chain - create container with length + table - make types public (will be needed in restart context)
2017-08-14 15:17:14 +00:00
const mbedtls_x509_crt_verify_chain *ver_chain,
Extract code to separate function for readablity
2017-07-05 15:18:42 +00:00
int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
void *p_vrfy )
{
int ret;
Fix MSVC 64-bit warnings "conversion from size_t to int, possible loss of data"
2017-08-28 11:25:55 +00:00
unsigned i;
Extract code to separate function for readablity
2017-07-05 15:18:42 +00:00
uint32_t cur_flags;
Rework type for verify chain - create container with length + table - make types public (will be needed in restart context)
2017-08-14 15:17:14 +00:00
const mbedtls_x509_crt_verify_chain_item *cur;
Extract code to separate function for readablity
2017-07-05 15:18:42 +00:00
Rework type for verify chain - create container with length + table - make types public (will be needed in restart context)
2017-08-14 15:17:14 +00:00
for( i = ver_chain->len; i != 0; --i )
Extract code to separate function for readablity
2017-07-05 15:18:42 +00:00
{
Rework type for verify chain - create container with length + table - make types public (will be needed in restart context)
2017-08-14 15:17:14 +00:00
cur = &ver_chain->items[i-1];
cur_flags = cur->flags;
Extract code to separate function for readablity
2017-07-05 15:18:42 +00:00
if( NULL != f_vrfy )
Fix MSVC 64-bit warnings "conversion from size_t to int, possible loss of data"
2017-08-28 11:25:55 +00:00
if( ( ret = f_vrfy( p_vrfy, cur->crt, (int) i-1, &cur_flags ) ) != 0 )
Extract code to separate function for readablity
2017-07-05 15:18:42 +00:00
return( ret );
*flags |= cur_flags;
}
return( 0 );
}
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
/*
Introduce mbedtls_x509_crt_verify_restartable()
2017-07-11 09:02:20 +00:00
* Verify the certificate validity (default profile, not restartable)
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
*/
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
int mbedtls_x509_crt_verify( mbedtls_x509_crt *crt,
mbedtls_x509_crt *trust_ca,
mbedtls_x509_crl *ca_crl,
Change X.509 verify flags to uint32_t
2015-05-11 17:54:43 +00:00
const char *cn, uint32_t *flags,
int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
Renamed x509parse_* functions to new form e.g. x509parse_crtfile -> x509_crt_parse_file
2013-09-18 11:46:23 +00:00
void *p_vrfy )
Create cert profile API (unimplemented yet)
2015-06-15 08:39:46 +00:00
{
Introduce mbedtls_x509_crt_verify_restartable()
2017-07-11 09:02:20 +00:00
return( mbedtls_x509_crt_verify_restartable( crt, trust_ca, ca_crl,
&mbedtls_x509_crt_profile_default, cn, flags,
f_vrfy, p_vrfy, NULL ) );
Create cert profile API (unimplemented yet)
2015-06-15 08:39:46 +00:00
}
/*
Introduce mbedtls_x509_crt_verify_restartable()
2017-07-11 09:02:20 +00:00
* Verify the certificate validity (user-chosen profile, not restartable)
*/
int mbedtls_x509_crt_verify_with_profile( mbedtls_x509_crt *crt,
mbedtls_x509_crt *trust_ca,
mbedtls_x509_crl *ca_crl,
const mbedtls_x509_crt_profile *profile,
const char *cn, uint32_t *flags,
int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
void *p_vrfy )
{
return( mbedtls_x509_crt_verify_restartable( crt, trust_ca, ca_crl,
profile, cn, flags, f_vrfy, p_vrfy, NULL ) );
}
/*
* Verify the certificate validity, with profile, restartable version
Add comments on chain verification cases This is the beginning of a series of commits refactoring the chain building/verification functions in order to: - make it simpler to understand and work with - prepare integration of restartable ECC
2017-06-29 08:45:25 +00:00
*
Update comments
2017-07-12 10:23:06 +00:00
* This function:
* - checks the requested CN (if any)
* - checks the type and size of the EE cert's key,
* as that isn't done as part of chain building/verification currently
* - builds and verifies the chain
* - then calls the callback and merges the flags
Create cert profile API (unimplemented yet)
2015-06-15 08:39:46 +00:00
*/
Introduce mbedtls_x509_crt_verify_restartable()
2017-07-11 09:02:20 +00:00
int mbedtls_x509_crt_verify_restartable( mbedtls_x509_crt *crt,
Create cert profile API (unimplemented yet)
2015-06-15 08:39:46 +00:00
mbedtls_x509_crt *trust_ca,
mbedtls_x509_crl *ca_crl,
const mbedtls_x509_crt_profile *profile,
const char *cn, uint32_t *flags,
int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
Introduce mbedtls_x509_crt_verify_restartable()
2017-07-11 09:02:20 +00:00
void *p_vrfy,
mbedtls_x509_crt_restart_ctx *rs_ctx )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
{
- Revamped x509_verify() and the SSL f_vrfy callback implementations
2012-09-28 07:10:55 +00:00
int ret;
Rework type for verify chain - create container with length + table - make types public (will be needed in restart context)
2017-08-14 15:17:14 +00:00
mbedtls_x509_crt_verify_chain ver_chain;
Better initialisation of ver_chain Use dedicated function for consistency, and initialise flags to -1 as this is the safe value.
2017-08-23 08:55:41 +00:00
uint32_t ee_flags;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
- Added CRL revocation support to x509parse_verify() - Fixed an off-by-one allocation in ssl_set_hostname() - Added CRL support to SSL/TLS code
2009-05-03 10:18:48 +00:00
*flags = 0;
Better initialisation of ver_chain Use dedicated function for consistency, and initialise flags to -1 as this is the safe value.
2017-08-23 08:55:41 +00:00
ee_flags = 0;
x509_crt_verify_chain_reset( &ver_chain );
- Added CRL revocation support to x509parse_verify() - Fixed an off-by-one allocation in ssl_set_hostname() - Added CRL support to SSL/TLS code
2009-05-03 10:18:48 +00:00
Improve behaviour on fatal errors If we didn't walk the whole chain, then there may be any kind of errors in the part of the chain we didn't check, so setting all flags looks like the safe thing to do.
2017-06-22 10:19:27 +00:00
if( profile == NULL )
{
ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA;
goto exit;
}
Extract name checking to separate function Just copy-paste and unindent
2017-07-03 23:13:44 +00:00
/* check name if requested */
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
if( cn != NULL )
Make use of CRT acquire/release in x509_crt_verify_restartable
2019-02-25 18:15:33 +00:00
{
ret = x509_crt_verify_name( crt, cn, &ee_flags );
if( ret != 0 )
return( ret );
}
{
mbedtls_pk_context *pk;
mbedtls_pk_type_t pk_type;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
ret = mbedtls_x509_crt_pk_acquire( crt, &pk );
Make use of CRT acquire/release in x509_crt_verify_restartable
2019-02-25 18:15:33 +00:00
if( ret != 0 )
return( MBEDTLS_ERR_X509_FATAL_ERROR );
/* Check the type and size of the key */
pk_type = mbedtls_pk_get_type( pk );
Fix missing check for RSA key length on EE certs - also adapt tests to use lesser requirement for compatibility with old testing material
2015-10-23 12:08:48 +00:00
Make use of CRT acquire/release in x509_crt_verify_restartable
2019-02-25 18:15:33 +00:00
if( x509_profile_check_pk_alg( profile, pk_type ) != 0 )
ee_flags |= MBEDTLS_X509_BADCERT_BAD_PK;
Fix missing check for RSA key length on EE certs - also adapt tests to use lesser requirement for compatibility with old testing material
2015-10-23 12:08:48 +00:00
Make use of CRT acquire/release in x509_crt_verify_restartable
2019-02-25 18:15:33 +00:00
if( x509_profile_check_key( profile, pk ) != 0 )
ee_flags |= MBEDTLS_X509_BADCERT_BAD_KEY;
Remove frame/pk parameter from mbedtls_x509_crt_xxx_release()
2019-03-05 13:50:56 +00:00
mbedtls_x509_crt_pk_release( crt );
Make use of CRT acquire/release in x509_crt_verify_restartable
2019-02-25 18:15:33 +00:00
}
Fix missing check for RSA key length on EE certs - also adapt tests to use lesser requirement for compatibility with old testing material
2015-10-23 12:08:48 +00:00
Update comments
2017-07-03 22:33:39 +00:00
/* Check the chain */
Make the ver_chain length explicit
2017-07-05 15:36:47 +00:00
ret = x509_crt_verify_chain( crt, trust_ca, ca_crl, profile,
Rework type for verify chain - create container with length + table - make types public (will be needed in restart context)
2017-08-14 15:17:14 +00:00
&ver_chain, rs_ctx );
Adapt function signatures to rs_ctx + ret
2017-07-17 08:26:19 +00:00
Start using an explicit stack for callback info This is the first step towards making verify_chain() iterative. While from a readability point of view the current recursive version is fine, one of the goals of this refactoring is to prepare for restartable ECC integration, which will need the explicit stack anyway.
2017-07-05 11:28:45 +00:00
if( ret != 0 )
goto exit;
Better initialisation of ver_chain Use dedicated function for consistency, and initialise flags to -1 as this is the safe value.
2017-08-23 08:55:41 +00:00
/* Merge end-entity flags */
ver_chain.items[0].flags |= ee_flags;
Extract code to separate function for readablity
2017-07-05 15:18:42 +00:00
/* Build final flags, calling callback on the way if any */
Rework type for verify chain - create container with length + table - make types public (will be needed in restart context)
2017-08-14 15:17:14 +00:00
ret = x509_crt_merge_flags_with_cb( flags, &ver_chain, f_vrfy, p_vrfy );
- Revamped x509_verify() and the SSL f_vrfy callback implementations
2012-09-28 07:10:55 +00:00
Improve behaviour on fatal errors If we didn't walk the whole chain, then there may be any kind of errors in the part of the chain we didn't check, so setting all flags looks like the safe thing to do.
2017-06-22 10:19:27 +00:00
exit:
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
if( rs_ctx != NULL && ret != MBEDTLS_ERR_ECP_IN_PROGRESS )
mbedtls_x509_crt_restart_free( rs_ctx );
#endif
Improve comments
2017-07-06 10:16:25 +00:00
/* prevent misuse of the vrfy callback - VERIFY_FAILED would be ignored by
* the SSL module for authmode optional, but non-zero return from the
* callback means a fatal error so it shouldn't be ignored */
Only return VERIFY_FAILED from a single point Everything else is a fatal error. Also improve documentation about that for the vrfy callback.
2017-06-26 08:11:49 +00:00
if( ret == MBEDTLS_ERR_X509_CERT_VERIFY_FAILED )
ret = MBEDTLS_ERR_X509_FATAL_ERROR;
Improve behaviour on fatal errors If we didn't walk the whole chain, then there may be any kind of errors in the part of the chain we didn't check, so setting all flags looks like the safe thing to do.
2017-06-22 10:19:27 +00:00
if( ret != 0 )
{
*flags = (uint32_t) -1;
return( ret );
}
- Revamped x509_verify() and the SSL f_vrfy callback implementations
2012-09-28 07:10:55 +00:00
if( *flags != 0 )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_X509_CERT_VERIFY_FAILED );
- Added verification callback in certificate verification chain in order to allow external blacklisting
2011-01-13 17:54:59 +00:00
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
return( 0 );
}
Introduced x509_crt_init(), x509_crl_init() and x509_csr_init()
2013-09-18 09:58:25 +00:00
/*
* Initialize a certificate chain
*/
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
void mbedtls_x509_crt_init( mbedtls_x509_crt *crt )
Introduced x509_crt_init(), x509_crl_init() and x509_csr_init()
2013-09-18 09:58:25 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
memset( crt, 0, sizeof(mbedtls_x509_crt) );
Introduced x509_crt_init(), x509_crl_init() and x509_csr_init()
2013-09-18 09:58:25 +00:00
}
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
/*
* Unallocate all certificate data
*/
Introduce helper functions to free X.509 names and sequences `mbedtls_x509_name` and `mbedtls_x509_sequence` are dynamically allocated linked lists that need a loop to free properly. Introduce a static helper function to do that and use it in `mbedtls_x509_crt_free()`, where the CRT's issuer and subject names (of type `mbedtls_x509_name`) and the SubjectAlternativeName and ExtendedKeyUsage extensions (of type `mbedtls_x509_sequence`) need freeing. Increases code-clarity and saves a few bytes of flash.
2019-02-15 17:15:53 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
void mbedtls_x509_crt_free( mbedtls_x509_crt *crt )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_x509_crt *cert_cur = crt;
mbedtls_x509_crt *cert_prv;
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
if( crt == NULL )
return;
do
{
Add parsing cache to `mbedtls_x509_crt` This commit replaces the dummy implementation of the CRT acquire/release framework by a cache-based implementation which remembers frame and PK associated to a CRT across multiple `acquire/release` pairs.
2019-02-25 13:50:14 +00:00
x509_crt_cache_free( cert_cur->cache );
mbedtls_free( cert_cur->cache );
Add compile-time option to remove legacy CRT fields
2019-02-28 13:23:38 +00:00
#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_pk_free( &cert_cur->pk );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
mbedtls_free( cert_cur->sig_opts );
Add sig_opts member to X509 structures
2014-06-05 13:14:28 +00:00
#endif
Give x509_{sequence|name}_free() external linkage With the introduction of `mbedtls_x509_crt_get_{issuer|name}()`, users need an easy way of freeing the dynamic name structures these functions return. To that end, this commit renames `x509_{sequence|name}_free()` to `mbedtls_x509_{sequence|name}_free()` and gives them external linkage.
2019-02-26 19:01:00 +00:00
mbedtls_x509_name_free( cert_cur->issuer.next );
mbedtls_x509_name_free( cert_cur->subject.next );
mbedtls_x509_sequence_free( cert_cur->ext_key_usage.next );
mbedtls_x509_sequence_free( cert_cur->subject_alt_names.next );
Add compile-time option to remove legacy CRT fields
2019-02-28 13:23:38 +00:00
#endif /* !MBEDTLS_X509_ON_DEMAND_PARSING */
- Clean Subject Alternative Name data
2012-02-11 18:42:45 +00:00
Add a new X.509 API call for copy-less parsing of CRTs Context: The existing API `mbedtls_x509_parse_crt_der()` for parsing DER encoded X.509 CRTs unconditionally makes creates a copy of the input buffer in RAM. While this comes at the benefit of easy use, -- specifically: allowing the user to free or re-use the input buffer right after the call -- it creates a significant memory overhead, as the CRT is duplicated in memory (at least temporarily). This might not be tolerable a resource constrained device. As a remedy, this commit adds a new X.509 API call `mbedtls_x509_parse_crt_der_nocopy()` which has the same signature as `mbedtls_x509_parse_crt_der()` and almost the same semantics, with one difference: The input buffer must persist and be unmodified for the lifetime of the established instance of `mbedtls_x509_crt`, that is, until `mbedtls_x509_crt_free()` is called.
2019-01-31 08:57:44 +00:00
if( cert_cur->raw.p != NULL && cert_cur->own_buffer )
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
{
Rename mbedtls_zeroize to mbedtls_platform_zeroize
2018-04-17 14:51:09 +00:00
mbedtls_platform_zeroize( cert_cur->raw.p, cert_cur->raw.len );
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_free( cert_cur->raw.p );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
}
cert_cur = cert_cur->next;
}
while( cert_cur != NULL );
cert_cur = crt;
do
{
cert_prv = cert_cur;
cert_cur = cert_cur->next;
Rename mbedtls_zeroize to mbedtls_platform_zeroize
2018-04-17 14:51:09 +00:00
mbedtls_platform_zeroize( cert_prv, sizeof( mbedtls_x509_crt ) );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
if( cert_prv != crt )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_free( cert_prv );
- Renamed include directory to polarssl
2009-01-03 21:22:43 +00:00
}
while( cert_cur != NULL );
}
Introduce mbedtls_x509_crt_verify_restartable()
2017-07-11 09:02:20 +00:00
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
/*
* Initialize a restart context
*/
void mbedtls_x509_crt_restart_init( mbedtls_x509_crt_restart_ctx *ctx )
{
Introduce mbedtls_pk_restart_ctx and use it The fact that you needed to pass a pointer to mbedtls_ecdsa_restart_ctx (or that you needed to know the key type of the PK context) was a breach of abstraction. Change the API (and callers) now, and the implementation will be changed in the next commit.
2017-08-17 12:33:31 +00:00
mbedtls_pk_restart_init( &ctx->pk );
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
ctx->parent = NULL;
ctx->fallback_parent = NULL;
Rename internal variable for consistency
2018-07-02 10:33:14 +00:00
ctx->fallback_signature_is_good = 0;
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
ctx->parent_is_trusted = -1;
Rework state saving for verify_chain() Child was almost redundant as it's already saved in ver_chain, except it was multiplexed to also indicate whether an operation is in progress. This commit removes it and introduces an explicit state variable instead. This state can be useful later if we start returning IN_PROGRESS at other points than find_parent() (for example when checking CRL). Note that the state goes none -> find_parent and stays there until the context is free(), as it's only on the first call that nothing was in progress.
2017-08-23 10:32:19 +00:00
ctx->in_progress = x509_crt_rs_none;
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
ctx->self_cnt = 0;
Better initialisation of ver_chain Use dedicated function for consistency, and initialise flags to -1 as this is the safe value.
2017-08-23 08:55:41 +00:00
x509_crt_verify_chain_reset( &ctx->ver_chain );
Introduce mbedtls_x509_crt_verify_restartable()
2017-07-11 09:02:20 +00:00
}
/*
* Free the components of a restart context
*/
void mbedtls_x509_crt_restart_free( mbedtls_x509_crt_restart_ctx *ctx )
{
if( ctx == NULL )
return;
Introduce mbedtls_pk_restart_ctx and use it The fact that you needed to pass a pointer to mbedtls_ecdsa_restart_ctx (or that you needed to know the key type of the PK context) was a breach of abstraction. Change the API (and callers) now, and the implementation will be changed in the next commit.
2017-08-17 12:33:31 +00:00
mbedtls_pk_restart_free( &ctx->pk );
Make verify() actually restartable
2017-08-14 16:04:19 +00:00
mbedtls_x509_crt_restart_init( ctx );
Introduce mbedtls_x509_crt_verify_restartable()
2017-07-11 09:02:20 +00:00
}
#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#endif /* MBEDTLS_X509_CRT_PARSE_C */
Reference in a new issue Copy permalink