edhoc 1.4.0 → 2.0.0

package/external/libedhoc/externals/mbedtls/library/common.h

@@ -1,325 +0,0 @@
-/**
- * \file common.h
- *
- * \brief Utility macros for internal use in the library
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
- */
-
-#ifndef MBEDTLS_LIBRARY_COMMON_H
-#define MBEDTLS_LIBRARY_COMMON_H
-
-#include "mbedtls/build_info.h"
-#include "alignment.h"
-
-#include <assert.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stddef.h>
-
-#if defined(__ARM_NEON)
-#include <arm_neon.h>
-#endif /* __ARM_NEON */
-
-/** Helper to define a function as static except when building invasive tests.
- *
- * If a function is only used inside its own source file and should be
- * declared `static` to allow the compiler to optimize for code size,
- * but that function has unit tests, define it with
- * ```
- * MBEDTLS_STATIC_TESTABLE int mbedtls_foo(...) { ... }
- * ```
- * and declare it in a header in the `library/` directory with
- * ```
- * #if defined(MBEDTLS_TEST_HOOKS)
- * int mbedtls_foo(...);
- * #endif
- * ```
- */
-#if defined(MBEDTLS_TEST_HOOKS)
-#define MBEDTLS_STATIC_TESTABLE
-#else
-#define MBEDTLS_STATIC_TESTABLE static
-#endif
-
-#if defined(MBEDTLS_TEST_HOOKS)
-extern void (*mbedtls_test_hook_test_fail)(const char *test, int line, const char *file);
-#define MBEDTLS_TEST_HOOK_TEST_ASSERT(TEST) \
-    do { \
-        if ((!(TEST)) && ((*mbedtls_test_hook_test_fail) != NULL)) \
-        { \
-            (*mbedtls_test_hook_test_fail)( #TEST, __LINE__, __FILE__); \
-        } \
-    } while (0)
-#else
-#define MBEDTLS_TEST_HOOK_TEST_ASSERT(TEST)
-#endif /* defined(MBEDTLS_TEST_HOOKS) */
-
-/** \def ARRAY_LENGTH
- * Return the number of elements of a static or stack array.
- *
- * \param array         A value of array (not pointer) type.
- *
- * \return The number of elements of the array.
- */
-/* A correct implementation of ARRAY_LENGTH, but which silently gives
- * a nonsensical result if called with a pointer rather than an array. */
-#define ARRAY_LENGTH_UNSAFE(array)            \
-    (sizeof(array) / sizeof(*(array)))
-
-#if defined(__GNUC__)
-/* Test if arg and &(arg)[0] have the same type. This is true if arg is
- * an array but not if it's a pointer. */
-#define IS_ARRAY_NOT_POINTER(arg)                                     \
-    (!__builtin_types_compatible_p(__typeof__(arg),                \
-                                   __typeof__(&(arg)[0])))
-/* A compile-time constant with the value 0. If `const_expr` is not a
- * compile-time constant with a nonzero value, cause a compile-time error. */
-#define STATIC_ASSERT_EXPR(const_expr)                                \
-    (0 && sizeof(struct { unsigned int STATIC_ASSERT : 1 - 2 * !(const_expr); }))
-
-/* Return the scalar value `value` (possibly promoted). This is a compile-time
- * constant if `value` is. `condition` must be a compile-time constant.
- * If `condition` is false, arrange to cause a compile-time error. */
-#define STATIC_ASSERT_THEN_RETURN(condition, value)   \
-    (STATIC_ASSERT_EXPR(condition) ? 0 : (value))
-
-#define ARRAY_LENGTH(array)                                           \
-    (STATIC_ASSERT_THEN_RETURN(IS_ARRAY_NOT_POINTER(array),         \
-                               ARRAY_LENGTH_UNSAFE(array)))
-
-#else
-/* If we aren't sure the compiler supports our non-standard tricks,
- * fall back to the unsafe implementation. */
-#define ARRAY_LENGTH(array) ARRAY_LENGTH_UNSAFE(array)
-#endif
-/** Allow library to access its structs' private members.
- *
- * Although structs defined in header files are publicly available,
- * their members are private and should not be accessed by the user.
- */
-#define MBEDTLS_ALLOW_PRIVATE_ACCESS
-
-/**
- * \brief       Securely zeroize a buffer then free it.
- *
- *              Similar to making consecutive calls to
- *              \c mbedtls_platform_zeroize() and \c mbedtls_free(), but has
- *              code size savings, and potential for optimisation in the future.
- *
- *              Guaranteed to be a no-op if \p buf is \c NULL and \p len is 0.
- *
- * \param buf   Buffer to be zeroized then freed.
- * \param len   Length of the buffer in bytes
- */
-void mbedtls_zeroize_and_free(void *buf, size_t len);
-
-/** Return an offset into a buffer.
- *
- * This is just the addition of an offset to a pointer, except that this
- * function also accepts an offset of 0 into a buffer whose pointer is null.
- * (`p + n` has undefined behavior when `p` is null, even when `n == 0`.
- * A null pointer is a valid buffer pointer when the size is 0, for example
- * as the result of `malloc(0)` on some platforms.)
- *
- * \param p     Pointer to a buffer of at least n bytes.
- *              This may be \p NULL if \p n is zero.
- * \param n     An offset in bytes.
- * \return      Pointer to offset \p n in the buffer \p p.
- *              Note that this is only a valid pointer if the size of the
- *              buffer is at least \p n + 1.
- */
-static inline unsigned char *mbedtls_buffer_offset(
-    unsigned char *p, size_t n)
-{
-    return p == NULL ? NULL : p + n;
-}
-
-/** Return an offset into a read-only buffer.
- *
- * Similar to mbedtls_buffer_offset(), but for const pointers.
- *
- * \param p     Pointer to a buffer of at least n bytes.
- *              This may be \p NULL if \p n is zero.
- * \param n     An offset in bytes.
- * \return      Pointer to offset \p n in the buffer \p p.
- *              Note that this is only a valid pointer if the size of the
- *              buffer is at least \p n + 1.
- */
-static inline const unsigned char *mbedtls_buffer_offset_const(
-    const unsigned char *p, size_t n)
-{
-    return p == NULL ? NULL : p + n;
-}
-
-/**
- * Perform a fast block XOR operation, such that
- * r[i] = a[i] ^ b[i] where 0 <= i < n
- *
- * \param   r Pointer to result (buffer of at least \p n bytes). \p r
- *            may be equal to either \p a or \p b, but behaviour when
- *            it overlaps in other ways is undefined.
- * \param   a Pointer to input (buffer of at least \p n bytes)
- * \param   b Pointer to input (buffer of at least \p n bytes)
- * \param   n Number of bytes to process.
- */
-inline void mbedtls_xor(unsigned char *r, const unsigned char *a, const unsigned char *b, size_t n)
-{
-    size_t i = 0;
-#if defined(MBEDTLS_EFFICIENT_UNALIGNED_ACCESS)
-#if defined(__ARM_NEON)
-    for (; (i + 16) <= n; i += 16) {
-        uint8x16_t v1 = vld1q_u8(a + i);
-        uint8x16_t v2 = vld1q_u8(b + i);
-        uint8x16_t x = veorq_u8(v1, v2);
-        vst1q_u8(r + i, x);
-    }
-#elif defined(__amd64__) || defined(__x86_64__) || defined(__aarch64__)
-    /* This codepath probably only makes sense on architectures with 64-bit registers */
-    for (; (i + 8) <= n; i += 8) {
-        uint64_t x = mbedtls_get_unaligned_uint64(a + i) ^ mbedtls_get_unaligned_uint64(b + i);
-        mbedtls_put_unaligned_uint64(r + i, x);
-    }
-#else
-    for (; (i + 4) <= n; i += 4) {
-        uint32_t x = mbedtls_get_unaligned_uint32(a + i) ^ mbedtls_get_unaligned_uint32(b + i);
-        mbedtls_put_unaligned_uint32(r + i, x);
-    }
-#endif
-#endif
-    for (; i < n; i++) {
-        r[i] = a[i] ^ b[i];
-    }
-}
-
-/**
- * Perform a fast block XOR operation, such that
- * r[i] = a[i] ^ b[i] where 0 <= i < n
- *
- * In some situations, this can perform better than mbedtls_xor (e.g., it's about 5%
- * better in AES-CBC).
- *
- * \param   r Pointer to result (buffer of at least \p n bytes). \p r
- *            may be equal to either \p a or \p b, but behaviour when
- *            it overlaps in other ways is undefined.
- * \param   a Pointer to input (buffer of at least \p n bytes)
- * \param   b Pointer to input (buffer of at least \p n bytes)
- * \param   n Number of bytes to process.
- */
-static inline void mbedtls_xor_no_simd(unsigned char *r,
-                                       const unsigned char *a,
-                                       const unsigned char *b,
-                                       size_t n)
-{
-    size_t i = 0;
-#if defined(MBEDTLS_EFFICIENT_UNALIGNED_ACCESS)
-#if defined(__amd64__) || defined(__x86_64__) || defined(__aarch64__)
-    /* This codepath probably only makes sense on architectures with 64-bit registers */
-    for (; (i + 8) <= n; i += 8) {
-        uint64_t x = mbedtls_get_unaligned_uint64(a + i) ^ mbedtls_get_unaligned_uint64(b + i);
-        mbedtls_put_unaligned_uint64(r + i, x);
-    }
-#else
-    for (; (i + 4) <= n; i += 4) {
-        uint32_t x = mbedtls_get_unaligned_uint32(a + i) ^ mbedtls_get_unaligned_uint32(b + i);
-        mbedtls_put_unaligned_uint32(r + i, x);
-    }
-#endif
-#endif
-    for (; i < n; i++) {
-        r[i] = a[i] ^ b[i];
-    }
-}
-
-/* Fix MSVC C99 compatible issue
- *      MSVC support __func__ from visual studio 2015( 1900 )
- *      Use MSVC predefine macro to avoid name check fail.
- */
-#if (defined(_MSC_VER) && (_MSC_VER <= 1900))
-#define /*no-check-names*/ __func__ __FUNCTION__
-#endif
-
-/* Define `asm` for compilers which don't define it. */
-/* *INDENT-OFF* */
-#ifndef asm
-#if defined(__IAR_SYSTEMS_ICC__)
-#define asm __asm
-#else
-#define asm __asm__
-#endif
-#endif
-/* *INDENT-ON* */
-
-/*
- * Define the constraint used for read-only pointer operands to aarch64 asm.
- *
- * This is normally the usual "r", but for aarch64_32 (aka ILP32,
- * as found in watchos), "p" is required to avoid warnings from clang.
- *
- * Note that clang does not recognise '+p' or '=p', and armclang
- * does not recognise 'p' at all. Therefore, to update a pointer from
- * aarch64 assembly, it is necessary to use something like:
- *
- * uintptr_t uptr = (uintptr_t) ptr;
- * asm( "ldr x4, [%x0], #8" ... : "+r" (uptr) : : )
- * ptr = (void*) uptr;
- *
- * Note that the "x" in "%x0" is neccessary; writing "%0" will cause warnings.
- */
-#if defined(__aarch64__) && defined(MBEDTLS_HAVE_ASM)
-#if UINTPTR_MAX == 0xfffffffful
-/* ILP32: Specify the pointer operand slightly differently, as per #7787. */
-#define MBEDTLS_ASM_AARCH64_PTR_CONSTRAINT "p"
-#elif UINTPTR_MAX == 0xfffffffffffffffful
-/* Normal case (64-bit pointers): use "r" as the constraint for pointer operands to asm */
-#define MBEDTLS_ASM_AARCH64_PTR_CONSTRAINT "r"
-#else
-#error "Unrecognised pointer size for aarch64"
-#endif
-#endif
-
-/* Always provide a static assert macro, so it can be used unconditionally.
- * It will expand to nothing on some systems.
- * Can be used outside functions (but don't add a trailing ';' in that case:
- * the semicolon is included here to avoid triggering -Wextra-semi when
- * MBEDTLS_STATIC_ASSERT() expands to nothing).
- * Can't use the C11-style `defined(static_assert)` on FreeBSD, since it
- * defines static_assert even with -std=c99, but then complains about it.
- */
-#if defined(static_assert) && !defined(__FreeBSD__)
-#define MBEDTLS_STATIC_ASSERT(expr, msg)    static_assert(expr, msg);
-#else
-#define MBEDTLS_STATIC_ASSERT(expr, msg)
-#endif
-
-/* Define compiler branch hints */
-#if defined(__has_builtin)
-#if __has_builtin(__builtin_expect)
-#define MBEDTLS_LIKELY(x)       __builtin_expect(!!(x), 1)
-#define MBEDTLS_UNLIKELY(x)     __builtin_expect(!!(x), 0)
-#endif
-#endif
-#if !defined(MBEDTLS_LIKELY)
-#define MBEDTLS_LIKELY(x)       x
-#define MBEDTLS_UNLIKELY(x)     x
-#endif
-
-#if defined(__GNUC__) && !defined(__ARMCC_VERSION) && !defined(__clang__) \
-    && !defined(__llvm__) && !defined(__INTEL_COMPILER)
-/* Defined if the compiler really is gcc and not clang, etc */
-#define MBEDTLS_COMPILER_IS_GCC
-#endif
-
-/* For gcc -Os, override with -O2 for a given function.
- *
- * This will not affect behaviour for other optimisation settings, e.g. -O0.
- */
-#if defined(MBEDTLS_COMPILER_IS_GCC) && defined(__OPTIMIZE_SIZE__)
-#define MBEDTLS_OPTIMIZE_FOR_PERFORMANCE __attribute__((optimize("-O2")))
-#else
-#define MBEDTLS_OPTIMIZE_FOR_PERFORMANCE
-#endif
-
-#endif /* MBEDTLS_LIBRARY_COMMON_H */

package/external/libedhoc/externals/mbedtls/library/constant_time.c

@@ -1,261 +0,0 @@
-/**
- *  Constant-time functions
- *
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
- */
-
-/*
- * The following functions are implemented without using comparison operators, as those
- * might be translated to branches by some compilers on some platforms.
- */
-
-#include <stdint.h>
-#include <limits.h>
-
-#include "common.h"
-#include "constant_time_internal.h"
-#include "mbedtls/constant_time.h"
-#include "mbedtls/error.h"
-#include "mbedtls/platform_util.h"
-
-#include <string.h>
-
-#if defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_SSL_SOME_SUITES_USE_MAC)
-#include "psa/crypto.h"
-/* Define a local translating function to save code size by not using too many
- * arguments in each translating place. */
-static int local_err_translation(psa_status_t status)
-{
-    return psa_status_to_mbedtls(status, psa_to_ssl_errors,
-                                 ARRAY_LENGTH(psa_to_ssl_errors),
-                                 psa_generic_status_to_mbedtls);
-}
-#define PSA_TO_MBEDTLS_ERR(status) local_err_translation(status)
-#endif
-
-#if !defined(MBEDTLS_CT_ASM)
-/*
- * Define an object with the value zero, such that the compiler cannot prove that it
- * has the value zero (because it is volatile, it "may be modified in ways unknown to
- * the implementation").
- */
-volatile mbedtls_ct_uint_t mbedtls_ct_zero = 0;
-#endif
-
-/*
- * Define MBEDTLS_EFFICIENT_UNALIGNED_VOLATILE_ACCESS where assembly is present to
- * perform fast unaligned access to volatile data.
- *
- * This is needed because mbedtls_get_unaligned_uintXX etc don't support volatile
- * memory accesses.
- *
- * Some of these definitions could be moved into alignment.h but for now they are
- * only used here.
- */
-#if defined(MBEDTLS_EFFICIENT_UNALIGNED_ACCESS) && \
-    ((defined(MBEDTLS_CT_ARM_ASM) && (UINTPTR_MAX == 0xfffffffful)) || \
-    defined(MBEDTLS_CT_AARCH64_ASM))
-/* We check pointer sizes to avoid issues with them not matching register size requirements */
-#define MBEDTLS_EFFICIENT_UNALIGNED_VOLATILE_ACCESS
-
-static inline uint32_t mbedtls_get_unaligned_volatile_uint32(volatile const unsigned char *p)
-{
-    /* This is UB, even where it's safe:
-     *    return *((volatile uint32_t*)p);
-     * so instead the same thing is expressed in assembly below.
-     */
-    uint32_t r;
-#if defined(MBEDTLS_CT_ARM_ASM)
-    asm volatile ("ldr %0, [%1]" : "=r" (r) : "r" (p) :);
-#elif defined(MBEDTLS_CT_AARCH64_ASM)
-    asm volatile ("ldr %w0, [%1]" : "=r" (r) : MBEDTLS_ASM_AARCH64_PTR_CONSTRAINT(p) :);
-#else
-#error "No assembly defined for mbedtls_get_unaligned_volatile_uint32"
-#endif
-    return r;
-}
-#endif /* defined(MBEDTLS_EFFICIENT_UNALIGNED_ACCESS) &&
-          (defined(MBEDTLS_CT_ARM_ASM) || defined(MBEDTLS_CT_AARCH64_ASM)) */
-
-int mbedtls_ct_memcmp(const void *a,
-                      const void *b,
-                      size_t n)
-{
-    size_t i = 0;
-    /*
-     * `A` and `B` are cast to volatile to ensure that the compiler
-     * generates code that always fully reads both buffers.
-     * Otherwise it could generate a test to exit early if `diff` has all
-     * bits set early in the loop.
-     */
-    volatile const unsigned char *A = (volatile const unsigned char *) a;
-    volatile const unsigned char *B = (volatile const unsigned char *) b;
-    uint32_t diff = 0;
-
-#if defined(MBEDTLS_EFFICIENT_UNALIGNED_VOLATILE_ACCESS)
-    for (; (i + 4) <= n; i += 4) {
-        uint32_t x = mbedtls_get_unaligned_volatile_uint32(A + i);
-        uint32_t y = mbedtls_get_unaligned_volatile_uint32(B + i);
-        diff |= x ^ y;
-    }
-#endif
-
-    for (; i < n; i++) {
-        /* Read volatile data in order before computing diff.
-         * This avoids IAR compiler warning:
-         * 'the order of volatile accesses is undefined ..' */
-        unsigned char x = A[i], y = B[i];
-        diff |= x ^ y;
-    }
-
-
-#if (INT_MAX < INT32_MAX)
-    /* We don't support int smaller than 32-bits, but if someone tried to build
-     * with this configuration, there is a risk that, for differing data, the
-     * only bits set in diff are in the top 16-bits, and would be lost by a
-     * simple cast from uint32 to int.
-     * This would have significant security implications, so protect against it. */
-#error "mbedtls_ct_memcmp() requires minimum 32-bit ints"
-#else
-    /* The bit-twiddling ensures that when we cast uint32_t to int, we are casting
-     * a value that is in the range 0..INT_MAX - a value larger than this would
-     * result in implementation defined behaviour.
-     *
-     * This ensures that the value returned by the function is non-zero iff
-     * diff is non-zero.
-     */
-    return (int) ((diff & 0xffff) | (diff >> 16));
-#endif
-}
-
-#if defined(MBEDTLS_NIST_KW_C)
-
-int mbedtls_ct_memcmp_partial(const void *a,
-                              const void *b,
-                              size_t n,
-                              size_t skip_head,
-                              size_t skip_tail)
-{
-    unsigned int diff = 0;
-
-    volatile const unsigned char *A = (volatile const unsigned char *) a;
-    volatile const unsigned char *B = (volatile const unsigned char *) b;
-
-    size_t valid_end = n - skip_tail;
-
-    for (size_t i = 0; i < n; i++) {
-        unsigned char x = A[i], y = B[i];
-        unsigned int d = x ^ y;
-        mbedtls_ct_condition_t valid = mbedtls_ct_bool_and(mbedtls_ct_uint_ge(i, skip_head),
-                                                           mbedtls_ct_uint_lt(i, valid_end));
-        diff |= mbedtls_ct_uint_if_else_0(valid, d);
-    }
-
-    /* Since we go byte-by-byte, the only bits set will be in the bottom 8 bits, so the
-     * cast from uint to int is safe. */
-    return (int) diff;
-}
-
-#endif
-
-#if defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_RSA_C) && !defined(MBEDTLS_RSA_ALT)
-
-void mbedtls_ct_memmove_left(void *start, size_t total, size_t offset)
-{
-    volatile unsigned char *buf = start;
-    for (size_t i = 0; i < total; i++) {
-        mbedtls_ct_condition_t no_op = mbedtls_ct_uint_gt(total - offset, i);
-        /* The first `total - offset` passes are a no-op. The last
-         * `offset` passes shift the data one byte to the left and
-         * zero out the last byte. */
-        for (size_t n = 0; n < total - 1; n++) {
-            unsigned char current = buf[n];
-            unsigned char next    = buf[n+1];
-            buf[n] = mbedtls_ct_uint_if(no_op, current, next);
-        }
-        buf[total-1] = mbedtls_ct_uint_if_else_0(no_op, buf[total-1]);
-    }
-}
-
-#endif /* MBEDTLS_PKCS1_V15 && MBEDTLS_RSA_C && ! MBEDTLS_RSA_ALT */
-
-void mbedtls_ct_memcpy_if(mbedtls_ct_condition_t condition,
-                          unsigned char *dest,
-                          const unsigned char *src1,
-                          const unsigned char *src2,
-                          size_t len)
-{
-#if defined(MBEDTLS_CT_SIZE_64)
-    const uint64_t mask     = (uint64_t) condition;
-    const uint64_t not_mask = (uint64_t) ~mbedtls_ct_compiler_opaque(condition);
-#else
-    const uint32_t mask     = (uint32_t) condition;
-    const uint32_t not_mask = (uint32_t) ~mbedtls_ct_compiler_opaque(condition);
-#endif
-
-    /* If src2 is NULL, setup src2 so that we read from the destination address.
-     *
-     * This means that if src2 == NULL && condition is false, the result will be a
-     * no-op because we read from dest and write the same data back into dest.
-     */
-    if (src2 == NULL) {
-        src2 = dest;
-    }
-
-    /* dest[i] = c1 == c2 ? src[i] : dest[i] */
-    size_t i = 0;
-#if defined(MBEDTLS_EFFICIENT_UNALIGNED_ACCESS)
-#if defined(MBEDTLS_CT_SIZE_64)
-    for (; (i + 8) <= len; i += 8) {
-        uint64_t a = mbedtls_get_unaligned_uint64(src1 + i) & mask;
-        uint64_t b = mbedtls_get_unaligned_uint64(src2 + i) & not_mask;
-        mbedtls_put_unaligned_uint64(dest + i, a | b);
-    }
-#else
-    for (; (i + 4) <= len; i += 4) {
-        uint32_t a = mbedtls_get_unaligned_uint32(src1 + i) & mask;
-        uint32_t b = mbedtls_get_unaligned_uint32(src2 + i) & not_mask;
-        mbedtls_put_unaligned_uint32(dest + i, a | b);
-    }
-#endif /* defined(MBEDTLS_CT_SIZE_64) */
-#endif /* MBEDTLS_EFFICIENT_UNALIGNED_ACCESS */
-    for (; i < len; i++) {
-        dest[i] = (src1[i] & mask) | (src2[i] & not_mask);
-    }
-}
-
-void mbedtls_ct_memcpy_offset(unsigned char *dest,
-                              const unsigned char *src,
-                              size_t offset,
-                              size_t offset_min,
-                              size_t offset_max,
-                              size_t len)
-{
-    size_t offsetval;
-
-    for (offsetval = offset_min; offsetval <= offset_max; offsetval++) {
-        mbedtls_ct_memcpy_if(mbedtls_ct_uint_eq(offsetval, offset), dest, src + offsetval, NULL,
-                             len);
-    }
-}
-
-#if defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_RSA_C) && !defined(MBEDTLS_RSA_ALT)
-
-void mbedtls_ct_zeroize_if(mbedtls_ct_condition_t condition, void *buf, size_t len)
-{
-    uint32_t mask = (uint32_t) ~condition;
-    uint8_t *p = (uint8_t *) buf;
-    size_t i = 0;
-#if defined(MBEDTLS_EFFICIENT_UNALIGNED_ACCESS)
-    for (; (i + 4) <= len; i += 4) {
-        mbedtls_put_unaligned_uint32((void *) (p + i),
-                                     mbedtls_get_unaligned_uint32((void *) (p + i)) & mask);
-    }
-#endif
-    for (; i < len; i++) {
-        p[i] = p[i] & mask;
-    }
-}
-
-#endif /* defined(MBEDTLS_PKCS1_V15) && defined(MBEDTLS_RSA_C) && !defined(MBEDTLS_RSA_ALT) */