BA / SerialCom

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of OmniWheels by Gustav Atmel

mbed-os/features/mbedtls/src/cipher.c@1:9c5af431a1f1, 2018-05-01 (annotated)

Committer:
gustavatmel
Date:
Tue May 01 15:47:08 2018 +0000
Revision:
1:9c5af431a1f1
sdf

Who changed what in which revision?

UserRevisionLine numberNew contents of line
gustavatmel 1:9c5af431a1f1 1 /**
gustavatmel 1:9c5af431a1f1 2 * \file cipher.c
gustavatmel 1:9c5af431a1f1 3 *
gustavatmel 1:9c5af431a1f1 4 * \brief Generic cipher wrapper for mbed TLS
gustavatmel 1:9c5af431a1f1 5 *
gustavatmel 1:9c5af431a1f1 6 * \author Adriaan de Jong <dejong@fox-it.com>
gustavatmel 1:9c5af431a1f1 7 *
gustavatmel 1:9c5af431a1f1 8 * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
gustavatmel 1:9c5af431a1f1 9 * SPDX-License-Identifier: Apache-2.0
gustavatmel 1:9c5af431a1f1 10 *
gustavatmel 1:9c5af431a1f1 11 * Licensed under the Apache License, Version 2.0 (the "License"); you may
gustavatmel 1:9c5af431a1f1 12 * not use this file except in compliance with the License.
gustavatmel 1:9c5af431a1f1 13 * You may obtain a copy of the License at
gustavatmel 1:9c5af431a1f1 14 *
gustavatmel 1:9c5af431a1f1 15 * http://www.apache.org/licenses/LICENSE-2.0
gustavatmel 1:9c5af431a1f1 16 *
gustavatmel 1:9c5af431a1f1 17 * Unless required by applicable law or agreed to in writing, software
gustavatmel 1:9c5af431a1f1 18 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
gustavatmel 1:9c5af431a1f1 19 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
gustavatmel 1:9c5af431a1f1 20 * See the License for the specific language governing permissions and
gustavatmel 1:9c5af431a1f1 21 * limitations under the License.
gustavatmel 1:9c5af431a1f1 22 *
gustavatmel 1:9c5af431a1f1 23 * This file is part of mbed TLS (https://tls.mbed.org)
gustavatmel 1:9c5af431a1f1 24 */
gustavatmel 1:9c5af431a1f1 25
gustavatmel 1:9c5af431a1f1 26 #if !defined(MBEDTLS_CONFIG_FILE)
gustavatmel 1:9c5af431a1f1 27 #include "mbedtls/config.h"
gustavatmel 1:9c5af431a1f1 28 #else
gustavatmel 1:9c5af431a1f1 29 #include MBEDTLS_CONFIG_FILE
gustavatmel 1:9c5af431a1f1 30 #endif
gustavatmel 1:9c5af431a1f1 31
gustavatmel 1:9c5af431a1f1 32 #if defined(MBEDTLS_CIPHER_C)
gustavatmel 1:9c5af431a1f1 33
gustavatmel 1:9c5af431a1f1 34 #include "mbedtls/cipher.h"
gustavatmel 1:9c5af431a1f1 35 #include "mbedtls/cipher_internal.h"
gustavatmel 1:9c5af431a1f1 36
gustavatmel 1:9c5af431a1f1 37 #include <stdlib.h>
gustavatmel 1:9c5af431a1f1 38 #include <string.h>
gustavatmel 1:9c5af431a1f1 39
gustavatmel 1:9c5af431a1f1 40 #if defined(MBEDTLS_GCM_C)
gustavatmel 1:9c5af431a1f1 41 #include "mbedtls/gcm.h"
gustavatmel 1:9c5af431a1f1 42 #endif
gustavatmel 1:9c5af431a1f1 43
gustavatmel 1:9c5af431a1f1 44 #if defined(MBEDTLS_CCM_C)
gustavatmel 1:9c5af431a1f1 45 #include "mbedtls/ccm.h"
gustavatmel 1:9c5af431a1f1 46 #endif
gustavatmel 1:9c5af431a1f1 47
gustavatmel 1:9c5af431a1f1 48 #if defined(MBEDTLS_CMAC_C)
gustavatmel 1:9c5af431a1f1 49 #include "mbedtls/cmac.h"
gustavatmel 1:9c5af431a1f1 50 #endif
gustavatmel 1:9c5af431a1f1 51
gustavatmel 1:9c5af431a1f1 52 #if defined(MBEDTLS_PLATFORM_C)
gustavatmel 1:9c5af431a1f1 53 #include "mbedtls/platform.h"
gustavatmel 1:9c5af431a1f1 54 #else
gustavatmel 1:9c5af431a1f1 55 #define mbedtls_calloc calloc
gustavatmel 1:9c5af431a1f1 56 #define mbedtls_free free
gustavatmel 1:9c5af431a1f1 57 #endif
gustavatmel 1:9c5af431a1f1 58
gustavatmel 1:9c5af431a1f1 59 #if defined(MBEDTLS_ARC4_C) || defined(MBEDTLS_CIPHER_NULL_CIPHER)
gustavatmel 1:9c5af431a1f1 60 #define MBEDTLS_CIPHER_MODE_STREAM
gustavatmel 1:9c5af431a1f1 61 #endif
gustavatmel 1:9c5af431a1f1 62
gustavatmel 1:9c5af431a1f1 63 /* Implementation that should never be optimized out by the compiler */
gustavatmel 1:9c5af431a1f1 64 static void mbedtls_zeroize( void *v, size_t n ) {
gustavatmel 1:9c5af431a1f1 65 volatile unsigned char *p = (unsigned char*)v; while( n-- ) *p++ = 0;
gustavatmel 1:9c5af431a1f1 66 }
gustavatmel 1:9c5af431a1f1 67
gustavatmel 1:9c5af431a1f1 68 static int supported_init = 0;
gustavatmel 1:9c5af431a1f1 69
gustavatmel 1:9c5af431a1f1 70 const int *mbedtls_cipher_list( void )
gustavatmel 1:9c5af431a1f1 71 {
gustavatmel 1:9c5af431a1f1 72 const mbedtls_cipher_definition_t *def;
gustavatmel 1:9c5af431a1f1 73 int *type;
gustavatmel 1:9c5af431a1f1 74
gustavatmel 1:9c5af431a1f1 75 if( ! supported_init )
gustavatmel 1:9c5af431a1f1 76 {
gustavatmel 1:9c5af431a1f1 77 def = mbedtls_cipher_definitions;
gustavatmel 1:9c5af431a1f1 78 type = mbedtls_cipher_supported;
gustavatmel 1:9c5af431a1f1 79
gustavatmel 1:9c5af431a1f1 80 while( def->type != 0 )
gustavatmel 1:9c5af431a1f1 81 *type++ = (*def++).type;
gustavatmel 1:9c5af431a1f1 82
gustavatmel 1:9c5af431a1f1 83 *type = 0;
gustavatmel 1:9c5af431a1f1 84
gustavatmel 1:9c5af431a1f1 85 supported_init = 1;
gustavatmel 1:9c5af431a1f1 86 }
gustavatmel 1:9c5af431a1f1 87
gustavatmel 1:9c5af431a1f1 88 return( mbedtls_cipher_supported );
gustavatmel 1:9c5af431a1f1 89 }
gustavatmel 1:9c5af431a1f1 90
gustavatmel 1:9c5af431a1f1 91 const mbedtls_cipher_info_t *mbedtls_cipher_info_from_type( const mbedtls_cipher_type_t cipher_type )
gustavatmel 1:9c5af431a1f1 92 {
gustavatmel 1:9c5af431a1f1 93 const mbedtls_cipher_definition_t *def;
gustavatmel 1:9c5af431a1f1 94
gustavatmel 1:9c5af431a1f1 95 for( def = mbedtls_cipher_definitions; def->info != NULL; def++ )
gustavatmel 1:9c5af431a1f1 96 if( def->type == cipher_type )
gustavatmel 1:9c5af431a1f1 97 return( def->info );
gustavatmel 1:9c5af431a1f1 98
gustavatmel 1:9c5af431a1f1 99 return( NULL );
gustavatmel 1:9c5af431a1f1 100 }
gustavatmel 1:9c5af431a1f1 101
gustavatmel 1:9c5af431a1f1 102 const mbedtls_cipher_info_t *mbedtls_cipher_info_from_string( const char *cipher_name )
gustavatmel 1:9c5af431a1f1 103 {
gustavatmel 1:9c5af431a1f1 104 const mbedtls_cipher_definition_t *def;
gustavatmel 1:9c5af431a1f1 105
gustavatmel 1:9c5af431a1f1 106 if( NULL == cipher_name )
gustavatmel 1:9c5af431a1f1 107 return( NULL );
gustavatmel 1:9c5af431a1f1 108
gustavatmel 1:9c5af431a1f1 109 for( def = mbedtls_cipher_definitions; def->info != NULL; def++ )
gustavatmel 1:9c5af431a1f1 110 if( ! strcmp( def->info->name, cipher_name ) )
gustavatmel 1:9c5af431a1f1 111 return( def->info );
gustavatmel 1:9c5af431a1f1 112
gustavatmel 1:9c5af431a1f1 113 return( NULL );
gustavatmel 1:9c5af431a1f1 114 }
gustavatmel 1:9c5af431a1f1 115
gustavatmel 1:9c5af431a1f1 116 const mbedtls_cipher_info_t *mbedtls_cipher_info_from_values( const mbedtls_cipher_id_t cipher_id,
gustavatmel 1:9c5af431a1f1 117 int key_bitlen,
gustavatmel 1:9c5af431a1f1 118 const mbedtls_cipher_mode_t mode )
gustavatmel 1:9c5af431a1f1 119 {
gustavatmel 1:9c5af431a1f1 120 const mbedtls_cipher_definition_t *def;
gustavatmel 1:9c5af431a1f1 121
gustavatmel 1:9c5af431a1f1 122 for( def = mbedtls_cipher_definitions; def->info != NULL; def++ )
gustavatmel 1:9c5af431a1f1 123 if( def->info->base->cipher == cipher_id &&
gustavatmel 1:9c5af431a1f1 124 def->info->key_bitlen == (unsigned) key_bitlen &&
gustavatmel 1:9c5af431a1f1 125 def->info->mode == mode )
gustavatmel 1:9c5af431a1f1 126 return( def->info );
gustavatmel 1:9c5af431a1f1 127
gustavatmel 1:9c5af431a1f1 128 return( NULL );
gustavatmel 1:9c5af431a1f1 129 }
gustavatmel 1:9c5af431a1f1 130
gustavatmel 1:9c5af431a1f1 131 void mbedtls_cipher_init( mbedtls_cipher_context_t *ctx )
gustavatmel 1:9c5af431a1f1 132 {
gustavatmel 1:9c5af431a1f1 133 memset( ctx, 0, sizeof( mbedtls_cipher_context_t ) );
gustavatmel 1:9c5af431a1f1 134 }
gustavatmel 1:9c5af431a1f1 135
gustavatmel 1:9c5af431a1f1 136 void mbedtls_cipher_free( mbedtls_cipher_context_t *ctx )
gustavatmel 1:9c5af431a1f1 137 {
gustavatmel 1:9c5af431a1f1 138 if( ctx == NULL )
gustavatmel 1:9c5af431a1f1 139 return;
gustavatmel 1:9c5af431a1f1 140
gustavatmel 1:9c5af431a1f1 141 #if defined(MBEDTLS_CMAC_C)
gustavatmel 1:9c5af431a1f1 142 if( ctx->cmac_ctx )
gustavatmel 1:9c5af431a1f1 143 {
gustavatmel 1:9c5af431a1f1 144 mbedtls_zeroize( ctx->cmac_ctx, sizeof( mbedtls_cmac_context_t ) );
gustavatmel 1:9c5af431a1f1 145 mbedtls_free( ctx->cmac_ctx );
gustavatmel 1:9c5af431a1f1 146 }
gustavatmel 1:9c5af431a1f1 147 #endif
gustavatmel 1:9c5af431a1f1 148
gustavatmel 1:9c5af431a1f1 149 if( ctx->cipher_ctx )
gustavatmel 1:9c5af431a1f1 150 ctx->cipher_info->base->ctx_free_func( ctx->cipher_ctx );
gustavatmel 1:9c5af431a1f1 151
gustavatmel 1:9c5af431a1f1 152 mbedtls_zeroize( ctx, sizeof(mbedtls_cipher_context_t) );
gustavatmel 1:9c5af431a1f1 153 }
gustavatmel 1:9c5af431a1f1 154
gustavatmel 1:9c5af431a1f1 155 int mbedtls_cipher_setup( mbedtls_cipher_context_t *ctx, const mbedtls_cipher_info_t *cipher_info )
gustavatmel 1:9c5af431a1f1 156 {
gustavatmel 1:9c5af431a1f1 157 if( NULL == cipher_info || NULL == ctx )
gustavatmel 1:9c5af431a1f1 158 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 159
gustavatmel 1:9c5af431a1f1 160 memset( ctx, 0, sizeof( mbedtls_cipher_context_t ) );
gustavatmel 1:9c5af431a1f1 161
gustavatmel 1:9c5af431a1f1 162 if( NULL == ( ctx->cipher_ctx = cipher_info->base->ctx_alloc_func() ) )
gustavatmel 1:9c5af431a1f1 163 return( MBEDTLS_ERR_CIPHER_ALLOC_FAILED );
gustavatmel 1:9c5af431a1f1 164
gustavatmel 1:9c5af431a1f1 165 ctx->cipher_info = cipher_info;
gustavatmel 1:9c5af431a1f1 166
gustavatmel 1:9c5af431a1f1 167 #if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
gustavatmel 1:9c5af431a1f1 168 /*
gustavatmel 1:9c5af431a1f1 169 * Ignore possible errors caused by a cipher mode that doesn't use padding
gustavatmel 1:9c5af431a1f1 170 */
gustavatmel 1:9c5af431a1f1 171 #if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
gustavatmel 1:9c5af431a1f1 172 (void) mbedtls_cipher_set_padding_mode( ctx, MBEDTLS_PADDING_PKCS7 );
gustavatmel 1:9c5af431a1f1 173 #else
gustavatmel 1:9c5af431a1f1 174 (void) mbedtls_cipher_set_padding_mode( ctx, MBEDTLS_PADDING_NONE );
gustavatmel 1:9c5af431a1f1 175 #endif
gustavatmel 1:9c5af431a1f1 176 #endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
gustavatmel 1:9c5af431a1f1 177
gustavatmel 1:9c5af431a1f1 178 return( 0 );
gustavatmel 1:9c5af431a1f1 179 }
gustavatmel 1:9c5af431a1f1 180
gustavatmel 1:9c5af431a1f1 181 int mbedtls_cipher_setkey( mbedtls_cipher_context_t *ctx, const unsigned char *key,
gustavatmel 1:9c5af431a1f1 182 int key_bitlen, const mbedtls_operation_t operation )
gustavatmel 1:9c5af431a1f1 183 {
gustavatmel 1:9c5af431a1f1 184 if( NULL == ctx || NULL == ctx->cipher_info )
gustavatmel 1:9c5af431a1f1 185 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 186
gustavatmel 1:9c5af431a1f1 187 if( ( ctx->cipher_info->flags & MBEDTLS_CIPHER_VARIABLE_KEY_LEN ) == 0 &&
gustavatmel 1:9c5af431a1f1 188 (int) ctx->cipher_info->key_bitlen != key_bitlen )
gustavatmel 1:9c5af431a1f1 189 {
gustavatmel 1:9c5af431a1f1 190 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 191 }
gustavatmel 1:9c5af431a1f1 192
gustavatmel 1:9c5af431a1f1 193 ctx->key_bitlen = key_bitlen;
gustavatmel 1:9c5af431a1f1 194 ctx->operation = operation;
gustavatmel 1:9c5af431a1f1 195
gustavatmel 1:9c5af431a1f1 196 /*
gustavatmel 1:9c5af431a1f1 197 * For CFB and CTR mode always use the encryption key schedule
gustavatmel 1:9c5af431a1f1 198 */
gustavatmel 1:9c5af431a1f1 199 if( MBEDTLS_ENCRYPT == operation ||
gustavatmel 1:9c5af431a1f1 200 MBEDTLS_MODE_CFB == ctx->cipher_info->mode ||
gustavatmel 1:9c5af431a1f1 201 MBEDTLS_MODE_CTR == ctx->cipher_info->mode )
gustavatmel 1:9c5af431a1f1 202 {
gustavatmel 1:9c5af431a1f1 203 return ctx->cipher_info->base->setkey_enc_func( ctx->cipher_ctx, key,
gustavatmel 1:9c5af431a1f1 204 ctx->key_bitlen );
gustavatmel 1:9c5af431a1f1 205 }
gustavatmel 1:9c5af431a1f1 206
gustavatmel 1:9c5af431a1f1 207 if( MBEDTLS_DECRYPT == operation )
gustavatmel 1:9c5af431a1f1 208 return ctx->cipher_info->base->setkey_dec_func( ctx->cipher_ctx, key,
gustavatmel 1:9c5af431a1f1 209 ctx->key_bitlen );
gustavatmel 1:9c5af431a1f1 210
gustavatmel 1:9c5af431a1f1 211 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 212 }
gustavatmel 1:9c5af431a1f1 213
gustavatmel 1:9c5af431a1f1 214 int mbedtls_cipher_set_iv( mbedtls_cipher_context_t *ctx,
gustavatmel 1:9c5af431a1f1 215 const unsigned char *iv, size_t iv_len )
gustavatmel 1:9c5af431a1f1 216 {
gustavatmel 1:9c5af431a1f1 217 size_t actual_iv_size;
gustavatmel 1:9c5af431a1f1 218
gustavatmel 1:9c5af431a1f1 219 if( NULL == ctx || NULL == ctx->cipher_info || NULL == iv )
gustavatmel 1:9c5af431a1f1 220 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 221
gustavatmel 1:9c5af431a1f1 222 /* avoid buffer overflow in ctx->iv */
gustavatmel 1:9c5af431a1f1 223 if( iv_len > MBEDTLS_MAX_IV_LENGTH )
gustavatmel 1:9c5af431a1f1 224 return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
gustavatmel 1:9c5af431a1f1 225
gustavatmel 1:9c5af431a1f1 226 if( ( ctx->cipher_info->flags & MBEDTLS_CIPHER_VARIABLE_IV_LEN ) != 0 )
gustavatmel 1:9c5af431a1f1 227 actual_iv_size = iv_len;
gustavatmel 1:9c5af431a1f1 228 else
gustavatmel 1:9c5af431a1f1 229 {
gustavatmel 1:9c5af431a1f1 230 actual_iv_size = ctx->cipher_info->iv_size;
gustavatmel 1:9c5af431a1f1 231
gustavatmel 1:9c5af431a1f1 232 /* avoid reading past the end of input buffer */
gustavatmel 1:9c5af431a1f1 233 if( actual_iv_size > iv_len )
gustavatmel 1:9c5af431a1f1 234 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 235 }
gustavatmel 1:9c5af431a1f1 236
gustavatmel 1:9c5af431a1f1 237 memcpy( ctx->iv, iv, actual_iv_size );
gustavatmel 1:9c5af431a1f1 238 ctx->iv_size = actual_iv_size;
gustavatmel 1:9c5af431a1f1 239
gustavatmel 1:9c5af431a1f1 240 return( 0 );
gustavatmel 1:9c5af431a1f1 241 }
gustavatmel 1:9c5af431a1f1 242
gustavatmel 1:9c5af431a1f1 243 int mbedtls_cipher_reset( mbedtls_cipher_context_t *ctx )
gustavatmel 1:9c5af431a1f1 244 {
gustavatmel 1:9c5af431a1f1 245 if( NULL == ctx || NULL == ctx->cipher_info )
gustavatmel 1:9c5af431a1f1 246 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 247
gustavatmel 1:9c5af431a1f1 248 ctx->unprocessed_len = 0;
gustavatmel 1:9c5af431a1f1 249
gustavatmel 1:9c5af431a1f1 250 return( 0 );
gustavatmel 1:9c5af431a1f1 251 }
gustavatmel 1:9c5af431a1f1 252
gustavatmel 1:9c5af431a1f1 253 #if defined(MBEDTLS_GCM_C)
gustavatmel 1:9c5af431a1f1 254 int mbedtls_cipher_update_ad( mbedtls_cipher_context_t *ctx,
gustavatmel 1:9c5af431a1f1 255 const unsigned char *ad, size_t ad_len )
gustavatmel 1:9c5af431a1f1 256 {
gustavatmel 1:9c5af431a1f1 257 if( NULL == ctx || NULL == ctx->cipher_info )
gustavatmel 1:9c5af431a1f1 258 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 259
gustavatmel 1:9c5af431a1f1 260 if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
gustavatmel 1:9c5af431a1f1 261 {
gustavatmel 1:9c5af431a1f1 262 return mbedtls_gcm_starts( (mbedtls_gcm_context *) ctx->cipher_ctx, ctx->operation,
gustavatmel 1:9c5af431a1f1 263 ctx->iv, ctx->iv_size, ad, ad_len );
gustavatmel 1:9c5af431a1f1 264 }
gustavatmel 1:9c5af431a1f1 265
gustavatmel 1:9c5af431a1f1 266 return( 0 );
gustavatmel 1:9c5af431a1f1 267 }
gustavatmel 1:9c5af431a1f1 268 #endif /* MBEDTLS_GCM_C */
gustavatmel 1:9c5af431a1f1 269
gustavatmel 1:9c5af431a1f1 270 int mbedtls_cipher_update( mbedtls_cipher_context_t *ctx, const unsigned char *input,
gustavatmel 1:9c5af431a1f1 271 size_t ilen, unsigned char *output, size_t *olen )
gustavatmel 1:9c5af431a1f1 272 {
gustavatmel 1:9c5af431a1f1 273 int ret;
gustavatmel 1:9c5af431a1f1 274 size_t block_size = 0;
gustavatmel 1:9c5af431a1f1 275
gustavatmel 1:9c5af431a1f1 276 if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
gustavatmel 1:9c5af431a1f1 277 {
gustavatmel 1:9c5af431a1f1 278 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 279 }
gustavatmel 1:9c5af431a1f1 280
gustavatmel 1:9c5af431a1f1 281 *olen = 0;
gustavatmel 1:9c5af431a1f1 282 block_size = mbedtls_cipher_get_block_size( ctx );
gustavatmel 1:9c5af431a1f1 283
gustavatmel 1:9c5af431a1f1 284 if( ctx->cipher_info->mode == MBEDTLS_MODE_ECB )
gustavatmel 1:9c5af431a1f1 285 {
gustavatmel 1:9c5af431a1f1 286 if( ilen != block_size )
gustavatmel 1:9c5af431a1f1 287 return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
gustavatmel 1:9c5af431a1f1 288
gustavatmel 1:9c5af431a1f1 289 *olen = ilen;
gustavatmel 1:9c5af431a1f1 290
gustavatmel 1:9c5af431a1f1 291 if( 0 != ( ret = ctx->cipher_info->base->ecb_func( ctx->cipher_ctx,
gustavatmel 1:9c5af431a1f1 292 ctx->operation, input, output ) ) )
gustavatmel 1:9c5af431a1f1 293 {
gustavatmel 1:9c5af431a1f1 294 return( ret );
gustavatmel 1:9c5af431a1f1 295 }
gustavatmel 1:9c5af431a1f1 296
gustavatmel 1:9c5af431a1f1 297 return( 0 );
gustavatmel 1:9c5af431a1f1 298 }
gustavatmel 1:9c5af431a1f1 299
gustavatmel 1:9c5af431a1f1 300 #if defined(MBEDTLS_GCM_C)
gustavatmel 1:9c5af431a1f1 301 if( ctx->cipher_info->mode == MBEDTLS_MODE_GCM )
gustavatmel 1:9c5af431a1f1 302 {
gustavatmel 1:9c5af431a1f1 303 *olen = ilen;
gustavatmel 1:9c5af431a1f1 304 return mbedtls_gcm_update( (mbedtls_gcm_context *) ctx->cipher_ctx, ilen, input,
gustavatmel 1:9c5af431a1f1 305 output );
gustavatmel 1:9c5af431a1f1 306 }
gustavatmel 1:9c5af431a1f1 307 #endif
gustavatmel 1:9c5af431a1f1 308
gustavatmel 1:9c5af431a1f1 309 if ( 0 == block_size )
gustavatmel 1:9c5af431a1f1 310 {
gustavatmel 1:9c5af431a1f1 311 return MBEDTLS_ERR_CIPHER_INVALID_CONTEXT;
gustavatmel 1:9c5af431a1f1 312 }
gustavatmel 1:9c5af431a1f1 313
gustavatmel 1:9c5af431a1f1 314 if( input == output &&
gustavatmel 1:9c5af431a1f1 315 ( ctx->unprocessed_len != 0 || ilen % block_size ) )
gustavatmel 1:9c5af431a1f1 316 {
gustavatmel 1:9c5af431a1f1 317 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 318 }
gustavatmel 1:9c5af431a1f1 319
gustavatmel 1:9c5af431a1f1 320 #if defined(MBEDTLS_CIPHER_MODE_CBC)
gustavatmel 1:9c5af431a1f1 321 if( ctx->cipher_info->mode == MBEDTLS_MODE_CBC )
gustavatmel 1:9c5af431a1f1 322 {
gustavatmel 1:9c5af431a1f1 323 size_t copy_len = 0;
gustavatmel 1:9c5af431a1f1 324
gustavatmel 1:9c5af431a1f1 325 /*
gustavatmel 1:9c5af431a1f1 326 * If there is not enough data for a full block, cache it.
gustavatmel 1:9c5af431a1f1 327 */
gustavatmel 1:9c5af431a1f1 328 if( ( ctx->operation == MBEDTLS_DECRYPT &&
gustavatmel 1:9c5af431a1f1 329 ilen <= block_size - ctx->unprocessed_len ) ||
gustavatmel 1:9c5af431a1f1 330 ( ctx->operation == MBEDTLS_ENCRYPT &&
gustavatmel 1:9c5af431a1f1 331 ilen < block_size - ctx->unprocessed_len ) )
gustavatmel 1:9c5af431a1f1 332 {
gustavatmel 1:9c5af431a1f1 333 memcpy( &( ctx->unprocessed_data[ctx->unprocessed_len] ), input,
gustavatmel 1:9c5af431a1f1 334 ilen );
gustavatmel 1:9c5af431a1f1 335
gustavatmel 1:9c5af431a1f1 336 ctx->unprocessed_len += ilen;
gustavatmel 1:9c5af431a1f1 337 return( 0 );
gustavatmel 1:9c5af431a1f1 338 }
gustavatmel 1:9c5af431a1f1 339
gustavatmel 1:9c5af431a1f1 340 /*
gustavatmel 1:9c5af431a1f1 341 * Process cached data first
gustavatmel 1:9c5af431a1f1 342 */
gustavatmel 1:9c5af431a1f1 343 if( 0 != ctx->unprocessed_len )
gustavatmel 1:9c5af431a1f1 344 {
gustavatmel 1:9c5af431a1f1 345 copy_len = block_size - ctx->unprocessed_len;
gustavatmel 1:9c5af431a1f1 346
gustavatmel 1:9c5af431a1f1 347 memcpy( &( ctx->unprocessed_data[ctx->unprocessed_len] ), input,
gustavatmel 1:9c5af431a1f1 348 copy_len );
gustavatmel 1:9c5af431a1f1 349
gustavatmel 1:9c5af431a1f1 350 if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
gustavatmel 1:9c5af431a1f1 351 ctx->operation, block_size, ctx->iv,
gustavatmel 1:9c5af431a1f1 352 ctx->unprocessed_data, output ) ) )
gustavatmel 1:9c5af431a1f1 353 {
gustavatmel 1:9c5af431a1f1 354 return( ret );
gustavatmel 1:9c5af431a1f1 355 }
gustavatmel 1:9c5af431a1f1 356
gustavatmel 1:9c5af431a1f1 357 *olen += block_size;
gustavatmel 1:9c5af431a1f1 358 output += block_size;
gustavatmel 1:9c5af431a1f1 359 ctx->unprocessed_len = 0;
gustavatmel 1:9c5af431a1f1 360
gustavatmel 1:9c5af431a1f1 361 input += copy_len;
gustavatmel 1:9c5af431a1f1 362 ilen -= copy_len;
gustavatmel 1:9c5af431a1f1 363 }
gustavatmel 1:9c5af431a1f1 364
gustavatmel 1:9c5af431a1f1 365 /*
gustavatmel 1:9c5af431a1f1 366 * Cache final, incomplete block
gustavatmel 1:9c5af431a1f1 367 */
gustavatmel 1:9c5af431a1f1 368 if( 0 != ilen )
gustavatmel 1:9c5af431a1f1 369 {
gustavatmel 1:9c5af431a1f1 370 if( 0 == block_size )
gustavatmel 1:9c5af431a1f1 371 {
gustavatmel 1:9c5af431a1f1 372 return MBEDTLS_ERR_CIPHER_INVALID_CONTEXT;
gustavatmel 1:9c5af431a1f1 373 }
gustavatmel 1:9c5af431a1f1 374
gustavatmel 1:9c5af431a1f1 375 copy_len = ilen % block_size;
gustavatmel 1:9c5af431a1f1 376 if( copy_len == 0 && ctx->operation == MBEDTLS_DECRYPT )
gustavatmel 1:9c5af431a1f1 377 copy_len = block_size;
gustavatmel 1:9c5af431a1f1 378
gustavatmel 1:9c5af431a1f1 379 memcpy( ctx->unprocessed_data, &( input[ilen - copy_len] ),
gustavatmel 1:9c5af431a1f1 380 copy_len );
gustavatmel 1:9c5af431a1f1 381
gustavatmel 1:9c5af431a1f1 382 ctx->unprocessed_len += copy_len;
gustavatmel 1:9c5af431a1f1 383 ilen -= copy_len;
gustavatmel 1:9c5af431a1f1 384 }
gustavatmel 1:9c5af431a1f1 385
gustavatmel 1:9c5af431a1f1 386 /*
gustavatmel 1:9c5af431a1f1 387 * Process remaining full blocks
gustavatmel 1:9c5af431a1f1 388 */
gustavatmel 1:9c5af431a1f1 389 if( ilen )
gustavatmel 1:9c5af431a1f1 390 {
gustavatmel 1:9c5af431a1f1 391 if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
gustavatmel 1:9c5af431a1f1 392 ctx->operation, ilen, ctx->iv, input, output ) ) )
gustavatmel 1:9c5af431a1f1 393 {
gustavatmel 1:9c5af431a1f1 394 return( ret );
gustavatmel 1:9c5af431a1f1 395 }
gustavatmel 1:9c5af431a1f1 396
gustavatmel 1:9c5af431a1f1 397 *olen += ilen;
gustavatmel 1:9c5af431a1f1 398 }
gustavatmel 1:9c5af431a1f1 399
gustavatmel 1:9c5af431a1f1 400 return( 0 );
gustavatmel 1:9c5af431a1f1 401 }
gustavatmel 1:9c5af431a1f1 402 #endif /* MBEDTLS_CIPHER_MODE_CBC */
gustavatmel 1:9c5af431a1f1 403
gustavatmel 1:9c5af431a1f1 404 #if defined(MBEDTLS_CIPHER_MODE_CFB)
gustavatmel 1:9c5af431a1f1 405 if( ctx->cipher_info->mode == MBEDTLS_MODE_CFB )
gustavatmel 1:9c5af431a1f1 406 {
gustavatmel 1:9c5af431a1f1 407 if( 0 != ( ret = ctx->cipher_info->base->cfb_func( ctx->cipher_ctx,
gustavatmel 1:9c5af431a1f1 408 ctx->operation, ilen, &ctx->unprocessed_len, ctx->iv,
gustavatmel 1:9c5af431a1f1 409 input, output ) ) )
gustavatmel 1:9c5af431a1f1 410 {
gustavatmel 1:9c5af431a1f1 411 return( ret );
gustavatmel 1:9c5af431a1f1 412 }
gustavatmel 1:9c5af431a1f1 413
gustavatmel 1:9c5af431a1f1 414 *olen = ilen;
gustavatmel 1:9c5af431a1f1 415
gustavatmel 1:9c5af431a1f1 416 return( 0 );
gustavatmel 1:9c5af431a1f1 417 }
gustavatmel 1:9c5af431a1f1 418 #endif /* MBEDTLS_CIPHER_MODE_CFB */
gustavatmel 1:9c5af431a1f1 419
gustavatmel 1:9c5af431a1f1 420 #if defined(MBEDTLS_CIPHER_MODE_CTR)
gustavatmel 1:9c5af431a1f1 421 if( ctx->cipher_info->mode == MBEDTLS_MODE_CTR )
gustavatmel 1:9c5af431a1f1 422 {
gustavatmel 1:9c5af431a1f1 423 if( 0 != ( ret = ctx->cipher_info->base->ctr_func( ctx->cipher_ctx,
gustavatmel 1:9c5af431a1f1 424 ilen, &ctx->unprocessed_len, ctx->iv,
gustavatmel 1:9c5af431a1f1 425 ctx->unprocessed_data, input, output ) ) )
gustavatmel 1:9c5af431a1f1 426 {
gustavatmel 1:9c5af431a1f1 427 return( ret );
gustavatmel 1:9c5af431a1f1 428 }
gustavatmel 1:9c5af431a1f1 429
gustavatmel 1:9c5af431a1f1 430 *olen = ilen;
gustavatmel 1:9c5af431a1f1 431
gustavatmel 1:9c5af431a1f1 432 return( 0 );
gustavatmel 1:9c5af431a1f1 433 }
gustavatmel 1:9c5af431a1f1 434 #endif /* MBEDTLS_CIPHER_MODE_CTR */
gustavatmel 1:9c5af431a1f1 435
gustavatmel 1:9c5af431a1f1 436 #if defined(MBEDTLS_CIPHER_MODE_STREAM)
gustavatmel 1:9c5af431a1f1 437 if( ctx->cipher_info->mode == MBEDTLS_MODE_STREAM )
gustavatmel 1:9c5af431a1f1 438 {
gustavatmel 1:9c5af431a1f1 439 if( 0 != ( ret = ctx->cipher_info->base->stream_func( ctx->cipher_ctx,
gustavatmel 1:9c5af431a1f1 440 ilen, input, output ) ) )
gustavatmel 1:9c5af431a1f1 441 {
gustavatmel 1:9c5af431a1f1 442 return( ret );
gustavatmel 1:9c5af431a1f1 443 }
gustavatmel 1:9c5af431a1f1 444
gustavatmel 1:9c5af431a1f1 445 *olen = ilen;
gustavatmel 1:9c5af431a1f1 446
gustavatmel 1:9c5af431a1f1 447 return( 0 );
gustavatmel 1:9c5af431a1f1 448 }
gustavatmel 1:9c5af431a1f1 449 #endif /* MBEDTLS_CIPHER_MODE_STREAM */
gustavatmel 1:9c5af431a1f1 450
gustavatmel 1:9c5af431a1f1 451 return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
gustavatmel 1:9c5af431a1f1 452 }
gustavatmel 1:9c5af431a1f1 453
gustavatmel 1:9c5af431a1f1 454 #if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
gustavatmel 1:9c5af431a1f1 455 #if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
gustavatmel 1:9c5af431a1f1 456 /*
gustavatmel 1:9c5af431a1f1 457 * PKCS7 (and PKCS5) padding: fill with ll bytes, with ll = padding_len
gustavatmel 1:9c5af431a1f1 458 */
gustavatmel 1:9c5af431a1f1 459 static void add_pkcs_padding( unsigned char *output, size_t output_len,
gustavatmel 1:9c5af431a1f1 460 size_t data_len )
gustavatmel 1:9c5af431a1f1 461 {
gustavatmel 1:9c5af431a1f1 462 size_t padding_len = output_len - data_len;
gustavatmel 1:9c5af431a1f1 463 unsigned char i;
gustavatmel 1:9c5af431a1f1 464
gustavatmel 1:9c5af431a1f1 465 for( i = 0; i < padding_len; i++ )
gustavatmel 1:9c5af431a1f1 466 output[data_len + i] = (unsigned char) padding_len;
gustavatmel 1:9c5af431a1f1 467 }
gustavatmel 1:9c5af431a1f1 468
gustavatmel 1:9c5af431a1f1 469 static int get_pkcs_padding( unsigned char *input, size_t input_len,
gustavatmel 1:9c5af431a1f1 470 size_t *data_len )
gustavatmel 1:9c5af431a1f1 471 {
gustavatmel 1:9c5af431a1f1 472 size_t i, pad_idx;
gustavatmel 1:9c5af431a1f1 473 unsigned char padding_len, bad = 0;
gustavatmel 1:9c5af431a1f1 474
gustavatmel 1:9c5af431a1f1 475 if( NULL == input || NULL == data_len )
gustavatmel 1:9c5af431a1f1 476 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 477
gustavatmel 1:9c5af431a1f1 478 padding_len = input[input_len - 1];
gustavatmel 1:9c5af431a1f1 479 *data_len = input_len - padding_len;
gustavatmel 1:9c5af431a1f1 480
gustavatmel 1:9c5af431a1f1 481 /* Avoid logical || since it results in a branch */
gustavatmel 1:9c5af431a1f1 482 bad |= padding_len > input_len;
gustavatmel 1:9c5af431a1f1 483 bad |= padding_len == 0;
gustavatmel 1:9c5af431a1f1 484
gustavatmel 1:9c5af431a1f1 485 /* The number of bytes checked must be independent of padding_len,
gustavatmel 1:9c5af431a1f1 486 * so pick input_len, which is usually 8 or 16 (one block) */
gustavatmel 1:9c5af431a1f1 487 pad_idx = input_len - padding_len;
gustavatmel 1:9c5af431a1f1 488 for( i = 0; i < input_len; i++ )
gustavatmel 1:9c5af431a1f1 489 bad |= ( input[i] ^ padding_len ) * ( i >= pad_idx );
gustavatmel 1:9c5af431a1f1 490
gustavatmel 1:9c5af431a1f1 491 return( MBEDTLS_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) );
gustavatmel 1:9c5af431a1f1 492 }
gustavatmel 1:9c5af431a1f1 493 #endif /* MBEDTLS_CIPHER_PADDING_PKCS7 */
gustavatmel 1:9c5af431a1f1 494
gustavatmel 1:9c5af431a1f1 495 #if defined(MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS)
gustavatmel 1:9c5af431a1f1 496 /*
gustavatmel 1:9c5af431a1f1 497 * One and zeros padding: fill with 80 00 ... 00
gustavatmel 1:9c5af431a1f1 498 */
gustavatmel 1:9c5af431a1f1 499 static void add_one_and_zeros_padding( unsigned char *output,
gustavatmel 1:9c5af431a1f1 500 size_t output_len, size_t data_len )
gustavatmel 1:9c5af431a1f1 501 {
gustavatmel 1:9c5af431a1f1 502 size_t padding_len = output_len - data_len;
gustavatmel 1:9c5af431a1f1 503 unsigned char i = 0;
gustavatmel 1:9c5af431a1f1 504
gustavatmel 1:9c5af431a1f1 505 output[data_len] = 0x80;
gustavatmel 1:9c5af431a1f1 506 for( i = 1; i < padding_len; i++ )
gustavatmel 1:9c5af431a1f1 507 output[data_len + i] = 0x00;
gustavatmel 1:9c5af431a1f1 508 }
gustavatmel 1:9c5af431a1f1 509
gustavatmel 1:9c5af431a1f1 510 static int get_one_and_zeros_padding( unsigned char *input, size_t input_len,
gustavatmel 1:9c5af431a1f1 511 size_t *data_len )
gustavatmel 1:9c5af431a1f1 512 {
gustavatmel 1:9c5af431a1f1 513 size_t i;
gustavatmel 1:9c5af431a1f1 514 unsigned char done = 0, prev_done, bad;
gustavatmel 1:9c5af431a1f1 515
gustavatmel 1:9c5af431a1f1 516 if( NULL == input || NULL == data_len )
gustavatmel 1:9c5af431a1f1 517 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 518
gustavatmel 1:9c5af431a1f1 519 bad = 0x80;
gustavatmel 1:9c5af431a1f1 520 *data_len = 0;
gustavatmel 1:9c5af431a1f1 521 for( i = input_len; i > 0; i-- )
gustavatmel 1:9c5af431a1f1 522 {
gustavatmel 1:9c5af431a1f1 523 prev_done = done;
gustavatmel 1:9c5af431a1f1 524 done |= ( input[i - 1] != 0 );
gustavatmel 1:9c5af431a1f1 525 *data_len |= ( i - 1 ) * ( done != prev_done );
gustavatmel 1:9c5af431a1f1 526 bad ^= input[i - 1] * ( done != prev_done );
gustavatmel 1:9c5af431a1f1 527 }
gustavatmel 1:9c5af431a1f1 528
gustavatmel 1:9c5af431a1f1 529 return( MBEDTLS_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) );
gustavatmel 1:9c5af431a1f1 530
gustavatmel 1:9c5af431a1f1 531 }
gustavatmel 1:9c5af431a1f1 532 #endif /* MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS */
gustavatmel 1:9c5af431a1f1 533
gustavatmel 1:9c5af431a1f1 534 #if defined(MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN)
gustavatmel 1:9c5af431a1f1 535 /*
gustavatmel 1:9c5af431a1f1 536 * Zeros and len padding: fill with 00 ... 00 ll, where ll is padding length
gustavatmel 1:9c5af431a1f1 537 */
gustavatmel 1:9c5af431a1f1 538 static void add_zeros_and_len_padding( unsigned char *output,
gustavatmel 1:9c5af431a1f1 539 size_t output_len, size_t data_len )
gustavatmel 1:9c5af431a1f1 540 {
gustavatmel 1:9c5af431a1f1 541 size_t padding_len = output_len - data_len;
gustavatmel 1:9c5af431a1f1 542 unsigned char i = 0;
gustavatmel 1:9c5af431a1f1 543
gustavatmel 1:9c5af431a1f1 544 for( i = 1; i < padding_len; i++ )
gustavatmel 1:9c5af431a1f1 545 output[data_len + i - 1] = 0x00;
gustavatmel 1:9c5af431a1f1 546 output[output_len - 1] = (unsigned char) padding_len;
gustavatmel 1:9c5af431a1f1 547 }
gustavatmel 1:9c5af431a1f1 548
gustavatmel 1:9c5af431a1f1 549 static int get_zeros_and_len_padding( unsigned char *input, size_t input_len,
gustavatmel 1:9c5af431a1f1 550 size_t *data_len )
gustavatmel 1:9c5af431a1f1 551 {
gustavatmel 1:9c5af431a1f1 552 size_t i, pad_idx;
gustavatmel 1:9c5af431a1f1 553 unsigned char padding_len, bad = 0;
gustavatmel 1:9c5af431a1f1 554
gustavatmel 1:9c5af431a1f1 555 if( NULL == input || NULL == data_len )
gustavatmel 1:9c5af431a1f1 556 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 557
gustavatmel 1:9c5af431a1f1 558 padding_len = input[input_len - 1];
gustavatmel 1:9c5af431a1f1 559 *data_len = input_len - padding_len;
gustavatmel 1:9c5af431a1f1 560
gustavatmel 1:9c5af431a1f1 561 /* Avoid logical || since it results in a branch */
gustavatmel 1:9c5af431a1f1 562 bad |= padding_len > input_len;
gustavatmel 1:9c5af431a1f1 563 bad |= padding_len == 0;
gustavatmel 1:9c5af431a1f1 564
gustavatmel 1:9c5af431a1f1 565 /* The number of bytes checked must be independent of padding_len */
gustavatmel 1:9c5af431a1f1 566 pad_idx = input_len - padding_len;
gustavatmel 1:9c5af431a1f1 567 for( i = 0; i < input_len - 1; i++ )
gustavatmel 1:9c5af431a1f1 568 bad |= input[i] * ( i >= pad_idx );
gustavatmel 1:9c5af431a1f1 569
gustavatmel 1:9c5af431a1f1 570 return( MBEDTLS_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) );
gustavatmel 1:9c5af431a1f1 571 }
gustavatmel 1:9c5af431a1f1 572 #endif /* MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN */
gustavatmel 1:9c5af431a1f1 573
gustavatmel 1:9c5af431a1f1 574 #if defined(MBEDTLS_CIPHER_PADDING_ZEROS)
gustavatmel 1:9c5af431a1f1 575 /*
gustavatmel 1:9c5af431a1f1 576 * Zero padding: fill with 00 ... 00
gustavatmel 1:9c5af431a1f1 577 */
gustavatmel 1:9c5af431a1f1 578 static void add_zeros_padding( unsigned char *output,
gustavatmel 1:9c5af431a1f1 579 size_t output_len, size_t data_len )
gustavatmel 1:9c5af431a1f1 580 {
gustavatmel 1:9c5af431a1f1 581 size_t i;
gustavatmel 1:9c5af431a1f1 582
gustavatmel 1:9c5af431a1f1 583 for( i = data_len; i < output_len; i++ )
gustavatmel 1:9c5af431a1f1 584 output[i] = 0x00;
gustavatmel 1:9c5af431a1f1 585 }
gustavatmel 1:9c5af431a1f1 586
gustavatmel 1:9c5af431a1f1 587 static int get_zeros_padding( unsigned char *input, size_t input_len,
gustavatmel 1:9c5af431a1f1 588 size_t *data_len )
gustavatmel 1:9c5af431a1f1 589 {
gustavatmel 1:9c5af431a1f1 590 size_t i;
gustavatmel 1:9c5af431a1f1 591 unsigned char done = 0, prev_done;
gustavatmel 1:9c5af431a1f1 592
gustavatmel 1:9c5af431a1f1 593 if( NULL == input || NULL == data_len )
gustavatmel 1:9c5af431a1f1 594 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 595
gustavatmel 1:9c5af431a1f1 596 *data_len = 0;
gustavatmel 1:9c5af431a1f1 597 for( i = input_len; i > 0; i-- )
gustavatmel 1:9c5af431a1f1 598 {
gustavatmel 1:9c5af431a1f1 599 prev_done = done;
gustavatmel 1:9c5af431a1f1 600 done |= ( input[i-1] != 0 );
gustavatmel 1:9c5af431a1f1 601 *data_len |= i * ( done != prev_done );
gustavatmel 1:9c5af431a1f1 602 }
gustavatmel 1:9c5af431a1f1 603
gustavatmel 1:9c5af431a1f1 604 return( 0 );
gustavatmel 1:9c5af431a1f1 605 }
gustavatmel 1:9c5af431a1f1 606 #endif /* MBEDTLS_CIPHER_PADDING_ZEROS */
gustavatmel 1:9c5af431a1f1 607
gustavatmel 1:9c5af431a1f1 608 /*
gustavatmel 1:9c5af431a1f1 609 * No padding: don't pad :)
gustavatmel 1:9c5af431a1f1 610 *
gustavatmel 1:9c5af431a1f1 611 * There is no add_padding function (check for NULL in mbedtls_cipher_finish)
gustavatmel 1:9c5af431a1f1 612 * but a trivial get_padding function
gustavatmel 1:9c5af431a1f1 613 */
gustavatmel 1:9c5af431a1f1 614 static int get_no_padding( unsigned char *input, size_t input_len,
gustavatmel 1:9c5af431a1f1 615 size_t *data_len )
gustavatmel 1:9c5af431a1f1 616 {
gustavatmel 1:9c5af431a1f1 617 if( NULL == input || NULL == data_len )
gustavatmel 1:9c5af431a1f1 618 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 619
gustavatmel 1:9c5af431a1f1 620 *data_len = input_len;
gustavatmel 1:9c5af431a1f1 621
gustavatmel 1:9c5af431a1f1 622 return( 0 );
gustavatmel 1:9c5af431a1f1 623 }
gustavatmel 1:9c5af431a1f1 624 #endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
gustavatmel 1:9c5af431a1f1 625
gustavatmel 1:9c5af431a1f1 626 int mbedtls_cipher_finish( mbedtls_cipher_context_t *ctx,
gustavatmel 1:9c5af431a1f1 627 unsigned char *output, size_t *olen )
gustavatmel 1:9c5af431a1f1 628 {
gustavatmel 1:9c5af431a1f1 629 if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
gustavatmel 1:9c5af431a1f1 630 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 631
gustavatmel 1:9c5af431a1f1 632 *olen = 0;
gustavatmel 1:9c5af431a1f1 633
gustavatmel 1:9c5af431a1f1 634 if( MBEDTLS_MODE_CFB == ctx->cipher_info->mode ||
gustavatmel 1:9c5af431a1f1 635 MBEDTLS_MODE_CTR == ctx->cipher_info->mode ||
gustavatmel 1:9c5af431a1f1 636 MBEDTLS_MODE_GCM == ctx->cipher_info->mode ||
gustavatmel 1:9c5af431a1f1 637 MBEDTLS_MODE_STREAM == ctx->cipher_info->mode )
gustavatmel 1:9c5af431a1f1 638 {
gustavatmel 1:9c5af431a1f1 639 return( 0 );
gustavatmel 1:9c5af431a1f1 640 }
gustavatmel 1:9c5af431a1f1 641
gustavatmel 1:9c5af431a1f1 642 if( MBEDTLS_MODE_ECB == ctx->cipher_info->mode )
gustavatmel 1:9c5af431a1f1 643 {
gustavatmel 1:9c5af431a1f1 644 if( ctx->unprocessed_len != 0 )
gustavatmel 1:9c5af431a1f1 645 return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
gustavatmel 1:9c5af431a1f1 646
gustavatmel 1:9c5af431a1f1 647 return( 0 );
gustavatmel 1:9c5af431a1f1 648 }
gustavatmel 1:9c5af431a1f1 649
gustavatmel 1:9c5af431a1f1 650 #if defined(MBEDTLS_CIPHER_MODE_CBC)
gustavatmel 1:9c5af431a1f1 651 if( MBEDTLS_MODE_CBC == ctx->cipher_info->mode )
gustavatmel 1:9c5af431a1f1 652 {
gustavatmel 1:9c5af431a1f1 653 int ret = 0;
gustavatmel 1:9c5af431a1f1 654
gustavatmel 1:9c5af431a1f1 655 if( MBEDTLS_ENCRYPT == ctx->operation )
gustavatmel 1:9c5af431a1f1 656 {
gustavatmel 1:9c5af431a1f1 657 /* check for 'no padding' mode */
gustavatmel 1:9c5af431a1f1 658 if( NULL == ctx->add_padding )
gustavatmel 1:9c5af431a1f1 659 {
gustavatmel 1:9c5af431a1f1 660 if( 0 != ctx->unprocessed_len )
gustavatmel 1:9c5af431a1f1 661 return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
gustavatmel 1:9c5af431a1f1 662
gustavatmel 1:9c5af431a1f1 663 return( 0 );
gustavatmel 1:9c5af431a1f1 664 }
gustavatmel 1:9c5af431a1f1 665
gustavatmel 1:9c5af431a1f1 666 ctx->add_padding( ctx->unprocessed_data, mbedtls_cipher_get_iv_size( ctx ),
gustavatmel 1:9c5af431a1f1 667 ctx->unprocessed_len );
gustavatmel 1:9c5af431a1f1 668 }
gustavatmel 1:9c5af431a1f1 669 else if( mbedtls_cipher_get_block_size( ctx ) != ctx->unprocessed_len )
gustavatmel 1:9c5af431a1f1 670 {
gustavatmel 1:9c5af431a1f1 671 /*
gustavatmel 1:9c5af431a1f1 672 * For decrypt operations, expect a full block,
gustavatmel 1:9c5af431a1f1 673 * or an empty block if no padding
gustavatmel 1:9c5af431a1f1 674 */
gustavatmel 1:9c5af431a1f1 675 if( NULL == ctx->add_padding && 0 == ctx->unprocessed_len )
gustavatmel 1:9c5af431a1f1 676 return( 0 );
gustavatmel 1:9c5af431a1f1 677
gustavatmel 1:9c5af431a1f1 678 return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
gustavatmel 1:9c5af431a1f1 679 }
gustavatmel 1:9c5af431a1f1 680
gustavatmel 1:9c5af431a1f1 681 /* cipher block */
gustavatmel 1:9c5af431a1f1 682 if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
gustavatmel 1:9c5af431a1f1 683 ctx->operation, mbedtls_cipher_get_block_size( ctx ), ctx->iv,
gustavatmel 1:9c5af431a1f1 684 ctx->unprocessed_data, output ) ) )
gustavatmel 1:9c5af431a1f1 685 {
gustavatmel 1:9c5af431a1f1 686 return( ret );
gustavatmel 1:9c5af431a1f1 687 }
gustavatmel 1:9c5af431a1f1 688
gustavatmel 1:9c5af431a1f1 689 /* Set output size for decryption */
gustavatmel 1:9c5af431a1f1 690 if( MBEDTLS_DECRYPT == ctx->operation )
gustavatmel 1:9c5af431a1f1 691 return ctx->get_padding( output, mbedtls_cipher_get_block_size( ctx ),
gustavatmel 1:9c5af431a1f1 692 olen );
gustavatmel 1:9c5af431a1f1 693
gustavatmel 1:9c5af431a1f1 694 /* Set output size for encryption */
gustavatmel 1:9c5af431a1f1 695 *olen = mbedtls_cipher_get_block_size( ctx );
gustavatmel 1:9c5af431a1f1 696 return( 0 );
gustavatmel 1:9c5af431a1f1 697 }
gustavatmel 1:9c5af431a1f1 698 #else
gustavatmel 1:9c5af431a1f1 699 ((void) output);
gustavatmel 1:9c5af431a1f1 700 #endif /* MBEDTLS_CIPHER_MODE_CBC */
gustavatmel 1:9c5af431a1f1 701
gustavatmel 1:9c5af431a1f1 702 return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
gustavatmel 1:9c5af431a1f1 703 }
gustavatmel 1:9c5af431a1f1 704
gustavatmel 1:9c5af431a1f1 705 #if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
gustavatmel 1:9c5af431a1f1 706 int mbedtls_cipher_set_padding_mode( mbedtls_cipher_context_t *ctx, mbedtls_cipher_padding_t mode )
gustavatmel 1:9c5af431a1f1 707 {
gustavatmel 1:9c5af431a1f1 708 if( NULL == ctx ||
gustavatmel 1:9c5af431a1f1 709 MBEDTLS_MODE_CBC != ctx->cipher_info->mode )
gustavatmel 1:9c5af431a1f1 710 {
gustavatmel 1:9c5af431a1f1 711 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 712 }
gustavatmel 1:9c5af431a1f1 713
gustavatmel 1:9c5af431a1f1 714 switch( mode )
gustavatmel 1:9c5af431a1f1 715 {
gustavatmel 1:9c5af431a1f1 716 #if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
gustavatmel 1:9c5af431a1f1 717 case MBEDTLS_PADDING_PKCS7:
gustavatmel 1:9c5af431a1f1 718 ctx->add_padding = add_pkcs_padding;
gustavatmel 1:9c5af431a1f1 719 ctx->get_padding = get_pkcs_padding;
gustavatmel 1:9c5af431a1f1 720 break;
gustavatmel 1:9c5af431a1f1 721 #endif
gustavatmel 1:9c5af431a1f1 722 #if defined(MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS)
gustavatmel 1:9c5af431a1f1 723 case MBEDTLS_PADDING_ONE_AND_ZEROS:
gustavatmel 1:9c5af431a1f1 724 ctx->add_padding = add_one_and_zeros_padding;
gustavatmel 1:9c5af431a1f1 725 ctx->get_padding = get_one_and_zeros_padding;
gustavatmel 1:9c5af431a1f1 726 break;
gustavatmel 1:9c5af431a1f1 727 #endif
gustavatmel 1:9c5af431a1f1 728 #if defined(MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN)
gustavatmel 1:9c5af431a1f1 729 case MBEDTLS_PADDING_ZEROS_AND_LEN:
gustavatmel 1:9c5af431a1f1 730 ctx->add_padding = add_zeros_and_len_padding;
gustavatmel 1:9c5af431a1f1 731 ctx->get_padding = get_zeros_and_len_padding;
gustavatmel 1:9c5af431a1f1 732 break;
gustavatmel 1:9c5af431a1f1 733 #endif
gustavatmel 1:9c5af431a1f1 734 #if defined(MBEDTLS_CIPHER_PADDING_ZEROS)
gustavatmel 1:9c5af431a1f1 735 case MBEDTLS_PADDING_ZEROS:
gustavatmel 1:9c5af431a1f1 736 ctx->add_padding = add_zeros_padding;
gustavatmel 1:9c5af431a1f1 737 ctx->get_padding = get_zeros_padding;
gustavatmel 1:9c5af431a1f1 738 break;
gustavatmel 1:9c5af431a1f1 739 #endif
gustavatmel 1:9c5af431a1f1 740 case MBEDTLS_PADDING_NONE:
gustavatmel 1:9c5af431a1f1 741 ctx->add_padding = NULL;
gustavatmel 1:9c5af431a1f1 742 ctx->get_padding = get_no_padding;
gustavatmel 1:9c5af431a1f1 743 break;
gustavatmel 1:9c5af431a1f1 744
gustavatmel 1:9c5af431a1f1 745 default:
gustavatmel 1:9c5af431a1f1 746 return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
gustavatmel 1:9c5af431a1f1 747 }
gustavatmel 1:9c5af431a1f1 748
gustavatmel 1:9c5af431a1f1 749 return( 0 );
gustavatmel 1:9c5af431a1f1 750 }
gustavatmel 1:9c5af431a1f1 751 #endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
gustavatmel 1:9c5af431a1f1 752
gustavatmel 1:9c5af431a1f1 753 #if defined(MBEDTLS_GCM_C)
gustavatmel 1:9c5af431a1f1 754 int mbedtls_cipher_write_tag( mbedtls_cipher_context_t *ctx,
gustavatmel 1:9c5af431a1f1 755 unsigned char *tag, size_t tag_len )
gustavatmel 1:9c5af431a1f1 756 {
gustavatmel 1:9c5af431a1f1 757 if( NULL == ctx || NULL == ctx->cipher_info || NULL == tag )
gustavatmel 1:9c5af431a1f1 758 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 759
gustavatmel 1:9c5af431a1f1 760 if( MBEDTLS_ENCRYPT != ctx->operation )
gustavatmel 1:9c5af431a1f1 761 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 762
gustavatmel 1:9c5af431a1f1 763 if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
gustavatmel 1:9c5af431a1f1 764 return mbedtls_gcm_finish( (mbedtls_gcm_context *) ctx->cipher_ctx, tag, tag_len );
gustavatmel 1:9c5af431a1f1 765
gustavatmel 1:9c5af431a1f1 766 return( 0 );
gustavatmel 1:9c5af431a1f1 767 }
gustavatmel 1:9c5af431a1f1 768
gustavatmel 1:9c5af431a1f1 769 int mbedtls_cipher_check_tag( mbedtls_cipher_context_t *ctx,
gustavatmel 1:9c5af431a1f1 770 const unsigned char *tag, size_t tag_len )
gustavatmel 1:9c5af431a1f1 771 {
gustavatmel 1:9c5af431a1f1 772 int ret;
gustavatmel 1:9c5af431a1f1 773
gustavatmel 1:9c5af431a1f1 774 if( NULL == ctx || NULL == ctx->cipher_info ||
gustavatmel 1:9c5af431a1f1 775 MBEDTLS_DECRYPT != ctx->operation )
gustavatmel 1:9c5af431a1f1 776 {
gustavatmel 1:9c5af431a1f1 777 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 778 }
gustavatmel 1:9c5af431a1f1 779
gustavatmel 1:9c5af431a1f1 780 if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
gustavatmel 1:9c5af431a1f1 781 {
gustavatmel 1:9c5af431a1f1 782 unsigned char check_tag[16];
gustavatmel 1:9c5af431a1f1 783 size_t i;
gustavatmel 1:9c5af431a1f1 784 int diff;
gustavatmel 1:9c5af431a1f1 785
gustavatmel 1:9c5af431a1f1 786 if( tag_len > sizeof( check_tag ) )
gustavatmel 1:9c5af431a1f1 787 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
gustavatmel 1:9c5af431a1f1 788
gustavatmel 1:9c5af431a1f1 789 if( 0 != ( ret = mbedtls_gcm_finish( (mbedtls_gcm_context *) ctx->cipher_ctx,
gustavatmel 1:9c5af431a1f1 790 check_tag, tag_len ) ) )
gustavatmel 1:9c5af431a1f1 791 {
gustavatmel 1:9c5af431a1f1 792 return( ret );
gustavatmel 1:9c5af431a1f1 793 }
gustavatmel 1:9c5af431a1f1 794
gustavatmel 1:9c5af431a1f1 795 /* Check the tag in "constant-time" */
gustavatmel 1:9c5af431a1f1 796 for( diff = 0, i = 0; i < tag_len; i++ )
gustavatmel 1:9c5af431a1f1 797 diff |= tag[i] ^ check_tag[i];
gustavatmel 1:9c5af431a1f1 798
gustavatmel 1:9c5af431a1f1 799 if( diff != 0 )
gustavatmel 1:9c5af431a1f1 800 return( MBEDTLS_ERR_CIPHER_AUTH_FAILED );
gustavatmel 1:9c5af431a1f1 801
gustavatmel 1:9c5af431a1f1 802 return( 0 );
gustavatmel 1:9c5af431a1f1 803 }
gustavatmel 1:9c5af431a1f1 804
gustavatmel 1:9c5af431a1f1 805 return( 0 );
gustavatmel 1:9c5af431a1f1 806 }
gustavatmel 1:9c5af431a1f1 807 #endif /* MBEDTLS_GCM_C */
gustavatmel 1:9c5af431a1f1 808
gustavatmel 1:9c5af431a1f1 809 /*
gustavatmel 1:9c5af431a1f1 810 * Packet-oriented wrapper for non-AEAD modes
gustavatmel 1:9c5af431a1f1 811 */
gustavatmel 1:9c5af431a1f1 812 int mbedtls_cipher_crypt( mbedtls_cipher_context_t *ctx,
gustavatmel 1:9c5af431a1f1 813 const unsigned char *iv, size_t iv_len,
gustavatmel 1:9c5af431a1f1 814 const unsigned char *input, size_t ilen,
gustavatmel 1:9c5af431a1f1 815 unsigned char *output, size_t *olen )
gustavatmel 1:9c5af431a1f1 816 {
gustavatmel 1:9c5af431a1f1 817 int ret;
gustavatmel 1:9c5af431a1f1 818 size_t finish_olen;
gustavatmel 1:9c5af431a1f1 819
gustavatmel 1:9c5af431a1f1 820 if( ( ret = mbedtls_cipher_set_iv( ctx, iv, iv_len ) ) != 0 )
gustavatmel 1:9c5af431a1f1 821 return( ret );
gustavatmel 1:9c5af431a1f1 822
gustavatmel 1:9c5af431a1f1 823 if( ( ret = mbedtls_cipher_reset( ctx ) ) != 0 )
gustavatmel 1:9c5af431a1f1 824 return( ret );
gustavatmel 1:9c5af431a1f1 825
gustavatmel 1:9c5af431a1f1 826 if( ( ret = mbedtls_cipher_update( ctx, input, ilen, output, olen ) ) != 0 )
gustavatmel 1:9c5af431a1f1 827 return( ret );
gustavatmel 1:9c5af431a1f1 828
gustavatmel 1:9c5af431a1f1 829 if( ( ret = mbedtls_cipher_finish( ctx, output + *olen, &finish_olen ) ) != 0 )
gustavatmel 1:9c5af431a1f1 830 return( ret );
gustavatmel 1:9c5af431a1f1 831
gustavatmel 1:9c5af431a1f1 832 *olen += finish_olen;
gustavatmel 1:9c5af431a1f1 833
gustavatmel 1:9c5af431a1f1 834 return( 0 );
gustavatmel 1:9c5af431a1f1 835 }
gustavatmel 1:9c5af431a1f1 836
gustavatmel 1:9c5af431a1f1 837 #if defined(MBEDTLS_CIPHER_MODE_AEAD)
gustavatmel 1:9c5af431a1f1 838 /*
gustavatmel 1:9c5af431a1f1 839 * Packet-oriented encryption for AEAD modes
gustavatmel 1:9c5af431a1f1 840 */
gustavatmel 1:9c5af431a1f1 841 int mbedtls_cipher_auth_encrypt( mbedtls_cipher_context_t *ctx,
gustavatmel 1:9c5af431a1f1 842 const unsigned char *iv, size_t iv_len,
gustavatmel 1:9c5af431a1f1 843 const unsigned char *ad, size_t ad_len,
gustavatmel 1:9c5af431a1f1 844 const unsigned char *input, size_t ilen,
gustavatmel 1:9c5af431a1f1 845 unsigned char *output, size_t *olen,
gustavatmel 1:9c5af431a1f1 846 unsigned char *tag, size_t tag_len )
gustavatmel 1:9c5af431a1f1 847 {
gustavatmel 1:9c5af431a1f1 848 #if defined(MBEDTLS_GCM_C)
gustavatmel 1:9c5af431a1f1 849 if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
gustavatmel 1:9c5af431a1f1 850 {
gustavatmel 1:9c5af431a1f1 851 *olen = ilen;
gustavatmel 1:9c5af431a1f1 852 return( mbedtls_gcm_crypt_and_tag( ctx->cipher_ctx, MBEDTLS_GCM_ENCRYPT, ilen,
gustavatmel 1:9c5af431a1f1 853 iv, iv_len, ad, ad_len, input, output,
gustavatmel 1:9c5af431a1f1 854 tag_len, tag ) );
gustavatmel 1:9c5af431a1f1 855 }
gustavatmel 1:9c5af431a1f1 856 #endif /* MBEDTLS_GCM_C */
gustavatmel 1:9c5af431a1f1 857 #if defined(MBEDTLS_CCM_C)
gustavatmel 1:9c5af431a1f1 858 if( MBEDTLS_MODE_CCM == ctx->cipher_info->mode )
gustavatmel 1:9c5af431a1f1 859 {
gustavatmel 1:9c5af431a1f1 860 *olen = ilen;
gustavatmel 1:9c5af431a1f1 861 return( mbedtls_ccm_encrypt_and_tag( ctx->cipher_ctx, ilen,
gustavatmel 1:9c5af431a1f1 862 iv, iv_len, ad, ad_len, input, output,
gustavatmel 1:9c5af431a1f1 863 tag, tag_len ) );
gustavatmel 1:9c5af431a1f1 864 }
gustavatmel 1:9c5af431a1f1 865 #endif /* MBEDTLS_CCM_C */
gustavatmel 1:9c5af431a1f1 866
gustavatmel 1:9c5af431a1f1 867 return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
gustavatmel 1:9c5af431a1f1 868 }
gustavatmel 1:9c5af431a1f1 869
gustavatmel 1:9c5af431a1f1 870 /*
gustavatmel 1:9c5af431a1f1 871 * Packet-oriented decryption for AEAD modes
gustavatmel 1:9c5af431a1f1 872 */
gustavatmel 1:9c5af431a1f1 873 int mbedtls_cipher_auth_decrypt( mbedtls_cipher_context_t *ctx,
gustavatmel 1:9c5af431a1f1 874 const unsigned char *iv, size_t iv_len,
gustavatmel 1:9c5af431a1f1 875 const unsigned char *ad, size_t ad_len,
gustavatmel 1:9c5af431a1f1 876 const unsigned char *input, size_t ilen,
gustavatmel 1:9c5af431a1f1 877 unsigned char *output, size_t *olen,
gustavatmel 1:9c5af431a1f1 878 const unsigned char *tag, size_t tag_len )
gustavatmel 1:9c5af431a1f1 879 {
gustavatmel 1:9c5af431a1f1 880 #if defined(MBEDTLS_GCM_C)
gustavatmel 1:9c5af431a1f1 881 if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
gustavatmel 1:9c5af431a1f1 882 {
gustavatmel 1:9c5af431a1f1 883 int ret;
gustavatmel 1:9c5af431a1f1 884
gustavatmel 1:9c5af431a1f1 885 *olen = ilen;
gustavatmel 1:9c5af431a1f1 886 ret = mbedtls_gcm_auth_decrypt( ctx->cipher_ctx, ilen,
gustavatmel 1:9c5af431a1f1 887 iv, iv_len, ad, ad_len,
gustavatmel 1:9c5af431a1f1 888 tag, tag_len, input, output );
gustavatmel 1:9c5af431a1f1 889
gustavatmel 1:9c5af431a1f1 890 if( ret == MBEDTLS_ERR_GCM_AUTH_FAILED )
gustavatmel 1:9c5af431a1f1 891 ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
gustavatmel 1:9c5af431a1f1 892
gustavatmel 1:9c5af431a1f1 893 return( ret );
gustavatmel 1:9c5af431a1f1 894 }
gustavatmel 1:9c5af431a1f1 895 #endif /* MBEDTLS_GCM_C */
gustavatmel 1:9c5af431a1f1 896 #if defined(MBEDTLS_CCM_C)
gustavatmel 1:9c5af431a1f1 897 if( MBEDTLS_MODE_CCM == ctx->cipher_info->mode )
gustavatmel 1:9c5af431a1f1 898 {
gustavatmel 1:9c5af431a1f1 899 int ret;
gustavatmel 1:9c5af431a1f1 900
gustavatmel 1:9c5af431a1f1 901 *olen = ilen;
gustavatmel 1:9c5af431a1f1 902 ret = mbedtls_ccm_auth_decrypt( ctx->cipher_ctx, ilen,
gustavatmel 1:9c5af431a1f1 903 iv, iv_len, ad, ad_len,
gustavatmel 1:9c5af431a1f1 904 input, output, tag, tag_len );
gustavatmel 1:9c5af431a1f1 905
gustavatmel 1:9c5af431a1f1 906 if( ret == MBEDTLS_ERR_CCM_AUTH_FAILED )
gustavatmel 1:9c5af431a1f1 907 ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
gustavatmel 1:9c5af431a1f1 908
gustavatmel 1:9c5af431a1f1 909 return( ret );
gustavatmel 1:9c5af431a1f1 910 }
gustavatmel 1:9c5af431a1f1 911 #endif /* MBEDTLS_CCM_C */
gustavatmel 1:9c5af431a1f1 912
gustavatmel 1:9c5af431a1f1 913 return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
gustavatmel 1:9c5af431a1f1 914 }
gustavatmel 1:9c5af431a1f1 915 #endif /* MBEDTLS_CIPHER_MODE_AEAD */
gustavatmel 1:9c5af431a1f1 916
gustavatmel 1:9c5af431a1f1 917 #endif /* MBEDTLS_CIPHER_C */