error.c 37.5 KB
Newer Older
1 2 3
/*
 *  Error message information
 *
Manuel Pégourié-Gonnard's avatar
Manuel Pégourié-Gonnard committed
4
 *  Copyright (C) 2006-2014, ARM Limited, All Rights Reserved
5
 *
Manuel Pégourié-Gonnard's avatar
Manuel Pégourié-Gonnard committed
6
 *  This file is part of mbed TLS (https://polarssl.org)
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

23
#if !defined(POLARSSL_CONFIG_FILE)
24
#include "polarssl/config.h"
25 26 27
#else
#include POLARSSL_CONFIG_FILE
#endif
28

29
#if defined(POLARSSL_ERROR_C) || defined(POLARSSL_ERROR_STRERROR_DUMMY)
30
#include "polarssl/error.h"
31
#include <string.h>
32 33
#endif

34 35 36 37 38 39
#if defined(POLARSSL_PLATFORM_C)
#include "polarssl/platform.h"
#else
#define polarssl_snprintf snprintf
#endif

40
#if defined(POLARSSL_ERROR_C)
41

42 43
#include <stdio.h>

44 45 46 47 48 49 50 51 52 53 54 55
#if defined(POLARSSL_AES_C)
#include "polarssl/aes.h"
#endif

#if defined(POLARSSL_BASE64_C)
#include "polarssl/base64.h"
#endif

#if defined(POLARSSL_BIGNUM_C)
#include "polarssl/bignum.h"
#endif

56 57 58 59
#if defined(POLARSSL_BLOWFISH_C)
#include "polarssl/blowfish.h"
#endif

60 61 62 63
#if defined(POLARSSL_CAMELLIA_C)
#include "polarssl/camellia.h"
#endif

64 65 66 67
#if defined(POLARSSL_CCM_C)
#include "polarssl/ccm.h"
#endif

68 69 70 71
#if defined(POLARSSL_CIPHER_C)
#include "polarssl/cipher.h"
#endif

72 73 74 75
#if defined(POLARSSL_CTR_DRBG_C)
#include "polarssl/ctr_drbg.h"
#endif

76 77 78 79 80 81 82 83
#if defined(POLARSSL_DES_C)
#include "polarssl/des.h"
#endif

#if defined(POLARSSL_DHM_C)
#include "polarssl/dhm.h"
#endif

Paul Bakker's avatar
Paul Bakker committed
84 85 86 87
#if defined(POLARSSL_ECP_C)
#include "polarssl/ecp.h"
#endif

88 89 90 91
#if defined(POLARSSL_ENTROPY_C)
#include "polarssl/entropy.h"
#endif

92 93 94 95
#if defined(POLARSSL_GCM_C)
#include "polarssl/gcm.h"
#endif

96 97 98 99
#if defined(POLARSSL_HMAC_DRBG_C)
#include "polarssl/hmac_drbg.h"
#endif

100 101 102 103
#if defined(POLARSSL_MD_C)
#include "polarssl/md.h"
#endif

104 105 106 107 108 109 110 111 112 113 114 115
#if defined(POLARSSL_MD2_C)
#include "polarssl/md2.h"
#endif

#if defined(POLARSSL_MD4_C)
#include "polarssl/md4.h"
#endif

#if defined(POLARSSL_MD5_C)
#include "polarssl/md5.h"
#endif

116 117 118 119
#if defined(POLARSSL_NET_C)
#include "polarssl/net.h"
#endif

120 121 122 123
#if defined(POLARSSL_OID_C)
#include "polarssl/oid.h"
#endif

124 125 126 127
#if defined(POLARSSL_PADLOCK_C)
#include "polarssl/padlock.h"
#endif

Paul Bakker's avatar
Paul Bakker committed
128 129 130 131
#if defined(POLARSSL_PBKDF2_C)
#include "polarssl/pbkdf2.h"
#endif

132
#if defined(POLARSSL_PEM_PARSE_C) || defined(POLARSSL_PEM_WRITE_C)
133 134 135
#include "polarssl/pem.h"
#endif

136 137 138 139
#if defined(POLARSSL_PK_C)
#include "polarssl/pk.h"
#endif

140 141 142 143
#if defined(POLARSSL_PKCS12_C)
#include "polarssl/pkcs12.h"
#endif

144 145 146 147
#if defined(POLARSSL_PKCS5_C)
#include "polarssl/pkcs5.h"
#endif

148 149 150 151
#if defined(POLARSSL_RIPEMD160_C)
#include "polarssl/ripemd160.h"
#endif

152 153 154 155
#if defined(POLARSSL_RSA_C)
#include "polarssl/rsa.h"
#endif

156 157 158 159
#if defined(POLARSSL_SHA1_C)
#include "polarssl/sha1.h"
#endif

160
#if defined(POLARSSL_SHA256_C)
161
#include "polarssl/sha256.h"
162 163
#endif

164
#if defined(POLARSSL_SHA512_C)
165
#include "polarssl/sha512.h"
166 167
#endif

168
#if defined(POLARSSL_SSL_TLS_C)
169 170 171
#include "polarssl/ssl.h"
#endif

172 173 174 175
#if defined(POLARSSL_THREADING_C)
#include "polarssl/threading.h"
#endif

176
#if defined(POLARSSL_X509_USE_C) || defined(POLARSSL_X509_CREATE_C)
177 178 179 180 181 182 183
#include "polarssl/x509.h"
#endif

#if defined(POLARSSL_XTEA_C)
#include "polarssl/xtea.h"
#endif

184 185
#if defined(_MSC_VER) && !defined  snprintf && !defined(EFIX64) && \
    !defined(EFI32)
186 187 188
#define  snprintf  _snprintf
#endif

189
void polarssl_strerror( int ret, char *buf, size_t buflen )
190 191 192 193
{
    size_t len;
    int use_ret;

194 195 196
    if( buflen == 0 )
        return;

197
    memset( buf, 0x00, buflen );
198 199 200
    /* Reduce buflen to make sure MSVC _snprintf() ends with \0 as well */
    buflen -= 1;

201 202 203 204 205 206 207 208 209
    if( ret < 0 )
        ret = -ret;

    if( ret & 0xFF80 )
    {
        use_ret = ret & 0xFF80;

        // High level error codes
        //
210
        // BEGIN generated code
211 212
#if defined(POLARSSL_CIPHER_C)
        if( use_ret == -(POLARSSL_ERR_CIPHER_FEATURE_UNAVAILABLE) )
213
            polarssl_snprintf( buf, buflen, "CIPHER - The selected feature is not available" );
214
        if( use_ret == -(POLARSSL_ERR_CIPHER_BAD_INPUT_DATA) )
215
            polarssl_snprintf( buf, buflen, "CIPHER - Bad input parameters to function" );
216
        if( use_ret == -(POLARSSL_ERR_CIPHER_ALLOC_FAILED) )
217
            polarssl_snprintf( buf, buflen, "CIPHER - Failed to allocate memory" );
218
        if( use_ret == -(POLARSSL_ERR_CIPHER_INVALID_PADDING) )
219
            polarssl_snprintf( buf, buflen, "CIPHER - Input data contains invalid padding and is rejected" );
220
        if( use_ret == -(POLARSSL_ERR_CIPHER_FULL_BLOCK_EXPECTED) )
221
            polarssl_snprintf( buf, buflen, "CIPHER - Decryption of block requires a full block" );
222
        if( use_ret == -(POLARSSL_ERR_CIPHER_AUTH_FAILED) )
223
            polarssl_snprintf( buf, buflen, "CIPHER - Authentication failed (for AEAD modes)" );
224 225
#endif /* POLARSSL_CIPHER_C */

226 227
#if defined(POLARSSL_DHM_C)
        if( use_ret == -(POLARSSL_ERR_DHM_BAD_INPUT_DATA) )
228
            polarssl_snprintf( buf, buflen, "DHM - Bad input parameters to function" );
229
        if( use_ret == -(POLARSSL_ERR_DHM_READ_PARAMS_FAILED) )
230
            polarssl_snprintf( buf, buflen, "DHM - Reading of the DHM parameters failed" );
231
        if( use_ret == -(POLARSSL_ERR_DHM_MAKE_PARAMS_FAILED) )
232
            polarssl_snprintf( buf, buflen, "DHM - Making of the DHM parameters failed" );
233
        if( use_ret == -(POLARSSL_ERR_DHM_READ_PUBLIC_FAILED) )
234
            polarssl_snprintf( buf, buflen, "DHM - Reading of the public values failed" );
235
        if( use_ret == -(POLARSSL_ERR_DHM_MAKE_PUBLIC_FAILED) )
236
            polarssl_snprintf( buf, buflen, "DHM - Making of the public value failed" );
237
        if( use_ret == -(POLARSSL_ERR_DHM_CALC_SECRET_FAILED) )
238
            polarssl_snprintf( buf, buflen, "DHM - Calculation of the DHM secret failed" );
239
        if( use_ret == -(POLARSSL_ERR_DHM_INVALID_FORMAT) )
240
            polarssl_snprintf( buf, buflen, "DHM - The ASN.1 data is not formatted correctly" );
241
        if( use_ret == -(POLARSSL_ERR_DHM_MALLOC_FAILED) )
242
            polarssl_snprintf( buf, buflen, "DHM - Allocation of memory failed" );
243
        if( use_ret == -(POLARSSL_ERR_DHM_FILE_IO_ERROR) )
244
            polarssl_snprintf( buf, buflen, "DHM - Read/write of file failed" );
245 246
#endif /* POLARSSL_DHM_C */

Paul Bakker's avatar
Paul Bakker committed
247 248
#if defined(POLARSSL_ECP_C)
        if( use_ret == -(POLARSSL_ERR_ECP_BAD_INPUT_DATA) )
249
            polarssl_snprintf( buf, buflen, "ECP - Bad input parameters to function" );
250
        if( use_ret == -(POLARSSL_ERR_ECP_BUFFER_TOO_SMALL) )
251
            polarssl_snprintf( buf, buflen, "ECP - The buffer is too small to write to" );
Paul Bakker's avatar
Paul Bakker committed
252
        if( use_ret == -(POLARSSL_ERR_ECP_FEATURE_UNAVAILABLE) )
253
            polarssl_snprintf( buf, buflen, "ECP - Requested curve not available" );
254
        if( use_ret == -(POLARSSL_ERR_ECP_VERIFY_FAILED) )
255
            polarssl_snprintf( buf, buflen, "ECP - The signature is not valid" );
256
        if( use_ret == -(POLARSSL_ERR_ECP_MALLOC_FAILED) )
257
            polarssl_snprintf( buf, buflen, "ECP - Memory allocation failed" );
258
        if( use_ret == -(POLARSSL_ERR_ECP_RANDOM_FAILED) )
259
            polarssl_snprintf( buf, buflen, "ECP - Generation of random value, such as (ephemeral) key, failed" );
260
        if( use_ret == -(POLARSSL_ERR_ECP_INVALID_KEY) )
261
            polarssl_snprintf( buf, buflen, "ECP - Invalid private or public key" );
262
        if( use_ret == -(POLARSSL_ERR_ECP_SIG_LEN_MISMATCH) )
263
            polarssl_snprintf( buf, buflen, "ECP - Signature is valid but shorter than the user-supplied length" );
Paul Bakker's avatar
Paul Bakker committed
264 265
#endif /* POLARSSL_ECP_C */

266 267
#if defined(POLARSSL_MD_C)
        if( use_ret == -(POLARSSL_ERR_MD_FEATURE_UNAVAILABLE) )
268
            polarssl_snprintf( buf, buflen, "MD - The selected feature is not available" );
269
        if( use_ret == -(POLARSSL_ERR_MD_BAD_INPUT_DATA) )
270
            polarssl_snprintf( buf, buflen, "MD - Bad input parameters to function" );
271
        if( use_ret == -(POLARSSL_ERR_MD_ALLOC_FAILED) )
272
            polarssl_snprintf( buf, buflen, "MD - Failed to allocate memory" );
273
        if( use_ret == -(POLARSSL_ERR_MD_FILE_IO_ERROR) )
274
            polarssl_snprintf( buf, buflen, "MD - Opening or reading of file failed" );
275 276
#endif /* POLARSSL_MD_C */

277
#if defined(POLARSSL_PEM_PARSE_C) || defined(POLARSSL_PEM_WRITE_C)
278
        if( use_ret == -(POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT) )
279
            polarssl_snprintf( buf, buflen, "PEM - No PEM header or footer found" );
280
        if( use_ret == -(POLARSSL_ERR_PEM_INVALID_DATA) )
281
            polarssl_snprintf( buf, buflen, "PEM - PEM string is not as expected" );
282
        if( use_ret == -(POLARSSL_ERR_PEM_MALLOC_FAILED) )
283
            polarssl_snprintf( buf, buflen, "PEM - Failed to allocate memory" );
284
        if( use_ret == -(POLARSSL_ERR_PEM_INVALID_ENC_IV) )
285
            polarssl_snprintf( buf, buflen, "PEM - RSA IV is not in hex-format" );
286
        if( use_ret == -(POLARSSL_ERR_PEM_UNKNOWN_ENC_ALG) )
287
            polarssl_snprintf( buf, buflen, "PEM - Unsupported key encryption algorithm" );
288
        if( use_ret == -(POLARSSL_ERR_PEM_PASSWORD_REQUIRED) )
289
            polarssl_snprintf( buf, buflen, "PEM - Private key password can't be empty" );
290
        if( use_ret == -(POLARSSL_ERR_PEM_PASSWORD_MISMATCH) )
291
            polarssl_snprintf( buf, buflen, "PEM - Given private key password does not allow for correct decryption" );
292
        if( use_ret == -(POLARSSL_ERR_PEM_FEATURE_UNAVAILABLE) )
293
            polarssl_snprintf( buf, buflen, "PEM - Unavailable feature, e.g. hashing/encryption combination" );
294
        if( use_ret == -(POLARSSL_ERR_PEM_BAD_INPUT_DATA) )
295
            polarssl_snprintf( buf, buflen, "PEM - Bad input parameters to function" );
296
#endif /* POLARSSL_PEM_PARSE_C || POLARSSL_PEM_WRITE_C */
297

298 299
#if defined(POLARSSL_PK_C)
        if( use_ret == -(POLARSSL_ERR_PK_MALLOC_FAILED) )
300
            polarssl_snprintf( buf, buflen, "PK - Memory alloation failed" );
301
        if( use_ret == -(POLARSSL_ERR_PK_TYPE_MISMATCH) )
302
            polarssl_snprintf( buf, buflen, "PK - Type mismatch, eg attempt to encrypt with an ECDSA key" );
Manuel Pégourié-Gonnard's avatar
Manuel Pégourié-Gonnard committed
303
        if( use_ret == -(POLARSSL_ERR_PK_BAD_INPUT_DATA) )
304
            polarssl_snprintf( buf, buflen, "PK - Bad input parameters to function" );
305
        if( use_ret == -(POLARSSL_ERR_PK_FILE_IO_ERROR) )
306
            polarssl_snprintf( buf, buflen, "PK - Read/write of file failed" );
307
        if( use_ret == -(POLARSSL_ERR_PK_KEY_INVALID_VERSION) )
308
            polarssl_snprintf( buf, buflen, "PK - Unsupported key version" );
309
        if( use_ret == -(POLARSSL_ERR_PK_KEY_INVALID_FORMAT) )
310
            polarssl_snprintf( buf, buflen, "PK - Invalid key tag or value" );
311
        if( use_ret == -(POLARSSL_ERR_PK_UNKNOWN_PK_ALG) )
312
            polarssl_snprintf( buf, buflen, "PK - Key algorithm is unsupported (only RSA and EC are supported)" );
313
        if( use_ret == -(POLARSSL_ERR_PK_PASSWORD_REQUIRED) )
314
            polarssl_snprintf( buf, buflen, "PK - Private key password can't be empty" );
315
        if( use_ret == -(POLARSSL_ERR_PK_PASSWORD_MISMATCH) )
316
            polarssl_snprintf( buf, buflen, "PK - Given private key password does not allow for correct decryption" );
317
        if( use_ret == -(POLARSSL_ERR_PK_INVALID_PUBKEY) )
318
            polarssl_snprintf( buf, buflen, "PK - The pubkey tag or value is invalid (only RSA and EC are supported)" );
319
        if( use_ret == -(POLARSSL_ERR_PK_INVALID_ALG) )
320
            polarssl_snprintf( buf, buflen, "PK - The algorithm tag or value is invalid" );
321
        if( use_ret == -(POLARSSL_ERR_PK_UNKNOWN_NAMED_CURVE) )
322
            polarssl_snprintf( buf, buflen, "PK - Elliptic curve is unsupported (only NIST curves are supported)" );
323
        if( use_ret == -(POLARSSL_ERR_PK_FEATURE_UNAVAILABLE) )
324
            polarssl_snprintf( buf, buflen, "PK - Unavailable feature, e.g. RSA disabled for RSA key" );
325
        if( use_ret == -(POLARSSL_ERR_PK_SIG_LEN_MISMATCH) )
326
            polarssl_snprintf( buf, buflen, "PK - The signature is valid but its length is less than expected" );
327 328
#endif /* POLARSSL_PK_C */

329 330
#if defined(POLARSSL_PKCS12_C)
        if( use_ret == -(POLARSSL_ERR_PKCS12_BAD_INPUT_DATA) )
331
            polarssl_snprintf( buf, buflen, "PKCS12 - Bad input parameters to function" );
332
        if( use_ret == -(POLARSSL_ERR_PKCS12_FEATURE_UNAVAILABLE) )
333
            polarssl_snprintf( buf, buflen, "PKCS12 - Feature not available, e.g. unsupported encryption scheme" );
334
        if( use_ret == -(POLARSSL_ERR_PKCS12_PBE_INVALID_FORMAT) )
335
            polarssl_snprintf( buf, buflen, "PKCS12 - PBE ASN.1 data not as expected" );
336
        if( use_ret == -(POLARSSL_ERR_PKCS12_PASSWORD_MISMATCH) )
337
            polarssl_snprintf( buf, buflen, "PKCS12 - Given private key password does not allow for correct decryption" );
338 339
#endif /* POLARSSL_PKCS12_C */

340 341
#if defined(POLARSSL_PKCS5_C)
        if( use_ret == -(POLARSSL_ERR_PKCS5_BAD_INPUT_DATA) )
342
            polarssl_snprintf( buf, buflen, "PKCS5 - Bad input parameters to function" );
343
        if( use_ret == -(POLARSSL_ERR_PKCS5_INVALID_FORMAT) )
344
            polarssl_snprintf( buf, buflen, "PKCS5 - Unexpected ASN.1 data" );
345
        if( use_ret == -(POLARSSL_ERR_PKCS5_FEATURE_UNAVAILABLE) )
346
            polarssl_snprintf( buf, buflen, "PKCS5 - Requested encryption or digest alg not available" );
347
        if( use_ret == -(POLARSSL_ERR_PKCS5_PASSWORD_MISMATCH) )
348
            polarssl_snprintf( buf, buflen, "PKCS5 - Given private key password does not allow for correct decryption" );
349 350
#endif /* POLARSSL_PKCS5_C */

351 352
#if defined(POLARSSL_RSA_C)
        if( use_ret == -(POLARSSL_ERR_RSA_BAD_INPUT_DATA) )
353
            polarssl_snprintf( buf, buflen, "RSA - Bad input parameters to function" );
354
        if( use_ret == -(POLARSSL_ERR_RSA_INVALID_PADDING) )
355
            polarssl_snprintf( buf, buflen, "RSA - Input data contains invalid padding and is rejected" );
356
        if( use_ret == -(POLARSSL_ERR_RSA_KEY_GEN_FAILED) )
357
            polarssl_snprintf( buf, buflen, "RSA - Something failed during generation of a key" );
358
        if( use_ret == -(POLARSSL_ERR_RSA_KEY_CHECK_FAILED) )
359
            polarssl_snprintf( buf, buflen, "RSA - Key failed to pass the libraries validity check" );
360
        if( use_ret == -(POLARSSL_ERR_RSA_PUBLIC_FAILED) )
361
            polarssl_snprintf( buf, buflen, "RSA - The public key operation failed" );
362
        if( use_ret == -(POLARSSL_ERR_RSA_PRIVATE_FAILED) )
363
            polarssl_snprintf( buf, buflen, "RSA - The private key operation failed" );
364
        if( use_ret == -(POLARSSL_ERR_RSA_VERIFY_FAILED) )
365
            polarssl_snprintf( buf, buflen, "RSA - The PKCS#1 verification failed" );
366
        if( use_ret == -(POLARSSL_ERR_RSA_OUTPUT_TOO_LARGE) )
367
            polarssl_snprintf( buf, buflen, "RSA - The output buffer for decryption is not large enough" );
368
        if( use_ret == -(POLARSSL_ERR_RSA_RNG_FAILED) )
369
            polarssl_snprintf( buf, buflen, "RSA - The random generator failed to generate non-zeros" );
370 371
#endif /* POLARSSL_RSA_C */

372
#if defined(POLARSSL_SSL_TLS_C)
373
        if( use_ret == -(POLARSSL_ERR_SSL_FEATURE_UNAVAILABLE) )
374
            polarssl_snprintf( buf, buflen, "SSL - The requested feature is not available" );
375
        if( use_ret == -(POLARSSL_ERR_SSL_BAD_INPUT_DATA) )
376
            polarssl_snprintf( buf, buflen, "SSL - Bad input parameters to function" );
377
        if( use_ret == -(POLARSSL_ERR_SSL_INVALID_MAC) )
378
            polarssl_snprintf( buf, buflen, "SSL - Verification of the message MAC failed" );
379
        if( use_ret == -(POLARSSL_ERR_SSL_INVALID_RECORD) )
380
            polarssl_snprintf( buf, buflen, "SSL - An invalid SSL record was received" );
381
        if( use_ret == -(POLARSSL_ERR_SSL_CONN_EOF) )
382
            polarssl_snprintf( buf, buflen, "SSL - The connection indicated an EOF" );
383
        if( use_ret == -(POLARSSL_ERR_SSL_UNKNOWN_CIPHER) )
384
            polarssl_snprintf( buf, buflen, "SSL - An unknown cipher was received" );
385
        if( use_ret == -(POLARSSL_ERR_SSL_NO_CIPHER_CHOSEN) )
386
            polarssl_snprintf( buf, buflen, "SSL - The server has no ciphersuites in common with the client" );
387
        if( use_ret == -(POLARSSL_ERR_SSL_NO_RNG) )
388
            polarssl_snprintf( buf, buflen, "SSL - No RNG was provided to the SSL module" );
389
        if( use_ret == -(POLARSSL_ERR_SSL_NO_CLIENT_CERTIFICATE) )
390
            polarssl_snprintf( buf, buflen, "SSL - No client certification received from the client, but required by the authentication mode" );
391
        if( use_ret == -(POLARSSL_ERR_SSL_CERTIFICATE_TOO_LARGE) )
392
            polarssl_snprintf( buf, buflen, "SSL - Our own certificate(s) is/are too large to send in an SSL message" );
393
        if( use_ret == -(POLARSSL_ERR_SSL_CERTIFICATE_REQUIRED) )
394
            polarssl_snprintf( buf, buflen, "SSL - The own certificate is not set, but needed by the server" );
395
        if( use_ret == -(POLARSSL_ERR_SSL_PRIVATE_KEY_REQUIRED) )
396
            polarssl_snprintf( buf, buflen, "SSL - The own private key or pre-shared key is not set, but needed" );
397
        if( use_ret == -(POLARSSL_ERR_SSL_CA_CHAIN_REQUIRED) )
398
            polarssl_snprintf( buf, buflen, "SSL - No CA Chain is set, but required to operate" );
399
        if( use_ret == -(POLARSSL_ERR_SSL_UNEXPECTED_MESSAGE) )
400
            polarssl_snprintf( buf, buflen, "SSL - An unexpected message was received from our peer" );
401
        if( use_ret == -(POLARSSL_ERR_SSL_FATAL_ALERT_MESSAGE) )
402
        {
403
            polarssl_snprintf( buf, buflen, "SSL - A fatal alert message was received from our peer" );
404 405
            return;
        }
406
        if( use_ret == -(POLARSSL_ERR_SSL_PEER_VERIFY_FAILED) )
407
            polarssl_snprintf( buf, buflen, "SSL - Verification of our peer failed" );
408
        if( use_ret == -(POLARSSL_ERR_SSL_PEER_CLOSE_NOTIFY) )
409
            polarssl_snprintf( buf, buflen, "SSL - The peer notified us that the connection is going to be closed" );
410
        if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_CLIENT_HELLO) )
411
            polarssl_snprintf( buf, buflen, "SSL - Processing of the ClientHello handshake message failed" );
412
        if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO) )
413
            polarssl_snprintf( buf, buflen, "SSL - Processing of the ServerHello handshake message failed" );
414
        if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE) )
415
            polarssl_snprintf( buf, buflen, "SSL - Processing of the Certificate handshake message failed" );
416
        if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE_REQUEST) )
417
            polarssl_snprintf( buf, buflen, "SSL - Processing of the CertificateRequest handshake message failed" );
418
        if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_SERVER_KEY_EXCHANGE) )
419
            polarssl_snprintf( buf, buflen, "SSL - Processing of the ServerKeyExchange handshake message failed" );
420
        if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_SERVER_HELLO_DONE) )
421
            polarssl_snprintf( buf, buflen, "SSL - Processing of the ServerHelloDone handshake message failed" );
422
        if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE) )
423
            polarssl_snprintf( buf, buflen, "SSL - Processing of the ClientKeyExchange handshake message failed" );
424
        if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_RP) )
425
            polarssl_snprintf( buf, buflen, "SSL - Processing of the ClientKeyExchange handshake message failed in DHM / ECDH Read Public" );
426
        if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_CLIENT_KEY_EXCHANGE_CS) )
427
            polarssl_snprintf( buf, buflen, "SSL - Processing of the ClientKeyExchange handshake message failed in DHM / ECDH Calculate Secret" );
428
        if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_CERTIFICATE_VERIFY) )
429
            polarssl_snprintf( buf, buflen, "SSL - Processing of the CertificateVerify handshake message failed" );
430
        if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_CHANGE_CIPHER_SPEC) )
431
            polarssl_snprintf( buf, buflen, "SSL - Processing of the ChangeCipherSpec handshake message failed" );
432
        if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_FINISHED) )
433
            polarssl_snprintf( buf, buflen, "SSL - Processing of the Finished handshake message failed" );
434
        if( use_ret == -(POLARSSL_ERR_SSL_MALLOC_FAILED) )
435
            polarssl_snprintf( buf, buflen, "SSL - Memory allocation failed" );
436
        if( use_ret == -(POLARSSL_ERR_SSL_HW_ACCEL_FAILED) )
437
            polarssl_snprintf( buf, buflen, "SSL - Hardware acceleration function returned with error" );
438
        if( use_ret == -(POLARSSL_ERR_SSL_HW_ACCEL_FALLTHROUGH) )
439
            polarssl_snprintf( buf, buflen, "SSL - Hardware acceleration function skipped / left alone data" );
440
        if( use_ret == -(POLARSSL_ERR_SSL_COMPRESSION_FAILED) )
441
            polarssl_snprintf( buf, buflen, "SSL - Processing of the compression / decompression failed" );
442
        if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_PROTOCOL_VERSION) )
443
            polarssl_snprintf( buf, buflen, "SSL - Handshake protocol not within min/max boundaries" );
444
        if( use_ret == -(POLARSSL_ERR_SSL_BAD_HS_NEW_SESSION_TICKET) )
445
            polarssl_snprintf( buf, buflen, "SSL - Processing of the NewSessionTicket handshake message failed" );
446
        if( use_ret == -(POLARSSL_ERR_SSL_SESSION_TICKET_EXPIRED) )
447
            polarssl_snprintf( buf, buflen, "SSL - Session ticket has expired" );
448
        if( use_ret == -(POLARSSL_ERR_SSL_PK_TYPE_MISMATCH) )
449
            polarssl_snprintf( buf, buflen, "SSL - Public key type mismatch (eg, asked for RSA key exchange and presented EC key)" );
Paul Bakker's avatar
Paul Bakker committed
450
        if( use_ret == -(POLARSSL_ERR_SSL_UNKNOWN_IDENTITY) )
451
            polarssl_snprintf( buf, buflen, "SSL - Unknown identity received (eg, PSK identity)" );
452
        if( use_ret == -(POLARSSL_ERR_SSL_INTERNAL_ERROR) )
453
            polarssl_snprintf( buf, buflen, "SSL - Internal error (eg, unexpected failure in lower-level module)" );
454
        if( use_ret == -(POLARSSL_ERR_SSL_COUNTER_WRAPPING) )
455
            polarssl_snprintf( buf, buflen, "SSL - A counter would wrap (eg, too many messages exchanged)" );
456
        if( use_ret == -(POLARSSL_ERR_SSL_WAITING_SERVER_HELLO_RENEGO) )
457
            polarssl_snprintf( buf, buflen, "SSL - Unexpected message at ServerHello in renegotiation" );
458
        if( use_ret == -(POLARSSL_ERR_SSL_NO_USABLE_CIPHERSUITE) )
459
            polarssl_snprintf( buf, buflen, "SSL - None of the common ciphersuites is usable (eg, no suitable certificate, see debug messages)" );
460
#endif /* POLARSSL_SSL_TLS_C */
461

462
#if defined(POLARSSL_X509_USE_C) || defined(POLARSSL_X509_CREATE_C)
463
        if( use_ret == -(POLARSSL_ERR_X509_FEATURE_UNAVAILABLE) )
464
            polarssl_snprintf( buf, buflen, "X509 - Unavailable feature, e.g. RSA hashing/encryption combination" );
465
        if( use_ret == -(POLARSSL_ERR_X509_UNKNOWN_OID) )
466
            polarssl_snprintf( buf, buflen, "X509 - Requested OID is unknown" );
467
        if( use_ret == -(POLARSSL_ERR_X509_INVALID_FORMAT) )
468
            polarssl_snprintf( buf, buflen, "X509 - The CRT/CRL/CSR format is invalid, e.g. different type expected" );
469
        if( use_ret == -(POLARSSL_ERR_X509_INVALID_VERSION) )
470
            polarssl_snprintf( buf, buflen, "X509 - The CRT/CRL/CSR version element is invalid" );
471
        if( use_ret == -(POLARSSL_ERR_X509_INVALID_SERIAL) )
472
            polarssl_snprintf( buf, buflen, "X509 - The serial tag or value is invalid" );
473
        if( use_ret == -(POLARSSL_ERR_X509_INVALID_ALG) )
474
            polarssl_snprintf( buf, buflen, "X509 - The algorithm tag or value is invalid" );
475
        if( use_ret == -(POLARSSL_ERR_X509_INVALID_NAME) )
476
            polarssl_snprintf( buf, buflen, "X509 - The name tag or value is invalid" );
477
        if( use_ret == -(POLARSSL_ERR_X509_INVALID_DATE) )
478
            polarssl_snprintf( buf, buflen, "X509 - The date tag or value is invalid" );
479
        if( use_ret == -(POLARSSL_ERR_X509_INVALID_SIGNATURE) )
480
            polarssl_snprintf( buf, buflen, "X509 - The signature tag or value invalid" );
481
        if( use_ret == -(POLARSSL_ERR_X509_INVALID_EXTENSIONS) )
482
            polarssl_snprintf( buf, buflen, "X509 - The extension tag or value is invalid" );
483
        if( use_ret == -(POLARSSL_ERR_X509_UNKNOWN_VERSION) )
484
            polarssl_snprintf( buf, buflen, "X509 - CRT/CRL/CSR has an unsupported version number" );
485
        if( use_ret == -(POLARSSL_ERR_X509_UNKNOWN_SIG_ALG) )
486
            polarssl_snprintf( buf, buflen, "X509 - Signature algorithm (oid) is unsupported" );
487
        if( use_ret == -(POLARSSL_ERR_X509_SIG_MISMATCH) )
488
            polarssl_snprintf( buf, buflen, "X509 - Signature algorithms do not match. (see \\c ::x509_crt sig_oid)" );
489
        if( use_ret == -(POLARSSL_ERR_X509_CERT_VERIFY_FAILED) )
490
            polarssl_snprintf( buf, buflen, "X509 - Certificate verification failed, e.g. CRL, CA or signature check failed" );
491
        if( use_ret == -(POLARSSL_ERR_X509_CERT_UNKNOWN_FORMAT) )
492
            polarssl_snprintf( buf, buflen, "X509 - Format not recognized as DER or PEM" );
493
        if( use_ret == -(POLARSSL_ERR_X509_BAD_INPUT_DATA) )
494
            polarssl_snprintf( buf, buflen, "X509 - Input invalid" );
495
        if( use_ret == -(POLARSSL_ERR_X509_MALLOC_FAILED) )
496
            polarssl_snprintf( buf, buflen, "X509 - Allocation of memory failed" );
497
        if( use_ret == -(POLARSSL_ERR_X509_FILE_IO_ERROR) )
498
            polarssl_snprintf( buf, buflen, "X509 - Read/write of file failed" );
499
#endif /* POLARSSL_X509_USE,X509_CREATE_C */
500
        // END generated code
501

502
        if( strlen( buf ) == 0 )
503
            polarssl_snprintf( buf, buflen, "UNKNOWN ERROR CODE (%04X)", use_ret );
504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520
    }

    use_ret = ret & ~0xFF80;

    if( use_ret == 0 )
        return;

    // If high level code is present, make a concatenation between both
    // error strings.
    //
    len = strlen( buf );

    if( len > 0 )
    {
        if( buflen - len < 5 )
            return;

521
        polarssl_snprintf( buf + len, buflen - len, " : " );
522 523 524 525 526 527 528

        buf += len + 3;
        buflen -= len + 3;
    }

    // Low level error codes
    //
529
    // BEGIN generated code
530 531
#if defined(POLARSSL_AES_C)
    if( use_ret == -(POLARSSL_ERR_AES_INVALID_KEY_LENGTH) )
532
        polarssl_snprintf( buf, buflen, "AES - Invalid key length" );
533
    if( use_ret == -(POLARSSL_ERR_AES_INVALID_INPUT_LENGTH) )
534
        polarssl_snprintf( buf, buflen, "AES - Invalid data input length" );
535 536
#endif /* POLARSSL_AES_C */

537 538
#if defined(POLARSSL_ASN1_PARSE_C)
    if( use_ret == -(POLARSSL_ERR_ASN1_OUT_OF_DATA) )
539
        polarssl_snprintf( buf, buflen, "ASN1 - Out of data when parsing an ASN1 data structure" );
540
    if( use_ret == -(POLARSSL_ERR_ASN1_UNEXPECTED_TAG) )
541
        polarssl_snprintf( buf, buflen, "ASN1 - ASN1 tag was of an unexpected value" );
542
    if( use_ret == -(POLARSSL_ERR_ASN1_INVALID_LENGTH) )
543
        polarssl_snprintf( buf, buflen, "ASN1 - Error when trying to determine the length or invalid length" );
544
    if( use_ret == -(POLARSSL_ERR_ASN1_LENGTH_MISMATCH) )
545
        polarssl_snprintf( buf, buflen, "ASN1 - Actual length differs from expected length" );
546
    if( use_ret == -(POLARSSL_ERR_ASN1_INVALID_DATA) )
547
        polarssl_snprintf( buf, buflen, "ASN1 - Data is invalid. (not used)" );
548
    if( use_ret == -(POLARSSL_ERR_ASN1_MALLOC_FAILED) )
549
        polarssl_snprintf( buf, buflen, "ASN1 - Memory allocation failed" );
550
    if( use_ret == -(POLARSSL_ERR_ASN1_BUF_TOO_SMALL) )
551
        polarssl_snprintf( buf, buflen, "ASN1 - Buffer too small when writing ASN.1 data structure" );
552 553
#endif /* POLARSSL_ASN1_PARSE_C */

554 555
#if defined(POLARSSL_BASE64_C)
    if( use_ret == -(POLARSSL_ERR_BASE64_BUFFER_TOO_SMALL) )
556
        polarssl_snprintf( buf, buflen, "BASE64 - Output buffer too small" );
557
    if( use_ret == -(POLARSSL_ERR_BASE64_INVALID_CHARACTER) )
558
        polarssl_snprintf( buf, buflen, "BASE64 - Invalid character in input" );
559 560 561 562
#endif /* POLARSSL_BASE64_C */

#if defined(POLARSSL_BIGNUM_C)
    if( use_ret == -(POLARSSL_ERR_MPI_FILE_IO_ERROR) )
563
        polarssl_snprintf( buf, buflen, "BIGNUM - An error occurred while reading from or writing to a file" );
564
    if( use_ret == -(POLARSSL_ERR_MPI_BAD_INPUT_DATA) )
565
        polarssl_snprintf( buf, buflen, "BIGNUM - Bad input parameters to function" );
566
    if( use_ret == -(POLARSSL_ERR_MPI_INVALID_CHARACTER) )
567
        polarssl_snprintf( buf, buflen, "BIGNUM - There is an invalid character in the digit string" );
568
    if( use_ret == -(POLARSSL_ERR_MPI_BUFFER_TOO_SMALL) )
569
        polarssl_snprintf( buf, buflen, "BIGNUM - The buffer is too small to write to" );
570
    if( use_ret == -(POLARSSL_ERR_MPI_NEGATIVE_VALUE) )
571
        polarssl_snprintf( buf, buflen, "BIGNUM - The input arguments are negative or result in illegal output" );
572
    if( use_ret == -(POLARSSL_ERR_MPI_DIVISION_BY_ZERO) )
573
        polarssl_snprintf( buf, buflen, "BIGNUM - The input argument for division is zero, which is not allowed" );
574
    if( use_ret == -(POLARSSL_ERR_MPI_NOT_ACCEPTABLE) )
575
        polarssl_snprintf( buf, buflen, "BIGNUM - The input arguments are not acceptable" );
576
    if( use_ret == -(POLARSSL_ERR_MPI_MALLOC_FAILED) )
577
        polarssl_snprintf( buf, buflen, "BIGNUM - Memory allocation failed" );
578
#endif /* POLARSSL_BIGNUM_C */
579 580 581

#if defined(POLARSSL_BLOWFISH_C)
    if( use_ret == -(POLARSSL_ERR_BLOWFISH_INVALID_KEY_LENGTH) )
582
        polarssl_snprintf( buf, buflen, "BLOWFISH - Invalid key length" );
583
    if( use_ret == -(POLARSSL_ERR_BLOWFISH_INVALID_INPUT_LENGTH) )
584
        polarssl_snprintf( buf, buflen, "BLOWFISH - Invalid data input length" );
585
#endif /* POLARSSL_BLOWFISH_C */
586 587 588

#if defined(POLARSSL_CAMELLIA_C)
    if( use_ret == -(POLARSSL_ERR_CAMELLIA_INVALID_KEY_LENGTH) )
589
        polarssl_snprintf( buf, buflen, "CAMELLIA - Invalid key length" );
590
    if( use_ret == -(POLARSSL_ERR_CAMELLIA_INVALID_INPUT_LENGTH) )
591
        polarssl_snprintf( buf, buflen, "CAMELLIA - Invalid data input length" );
592 593
#endif /* POLARSSL_CAMELLIA_C */

594 595
#if defined(POLARSSL_CCM_C)
    if( use_ret == -(POLARSSL_ERR_CCM_BAD_INPUT) )
596
        polarssl_snprintf( buf, buflen, "CCM - Bad input parameters to function" );
597
    if( use_ret == -(POLARSSL_ERR_CCM_AUTH_FAILED) )
598
        polarssl_snprintf( buf, buflen, "CCM - Authenticated decryption failed" );
599 600
#endif /* POLARSSL_CCM_C */

601 602
#if defined(POLARSSL_CTR_DRBG_C)
    if( use_ret == -(POLARSSL_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED) )
603
        polarssl_snprintf( buf, buflen, "CTR_DRBG - The entropy source failed" );
604
    if( use_ret == -(POLARSSL_ERR_CTR_DRBG_REQUEST_TOO_BIG) )
605
        polarssl_snprintf( buf, buflen, "CTR_DRBG - Too many random requested in single call" );
606
    if( use_ret == -(POLARSSL_ERR_CTR_DRBG_INPUT_TOO_BIG) )
607
        polarssl_snprintf( buf, buflen, "CTR_DRBG - Input too large (Entropy + additional)" );
608
    if( use_ret == -(POLARSSL_ERR_CTR_DRBG_FILE_IO_ERROR) )
609
        polarssl_snprintf( buf, buflen, "CTR_DRBG - Read/write error in file" );
610 611
#endif /* POLARSSL_CTR_DRBG_C */

612 613
#if defined(POLARSSL_DES_C)
    if( use_ret == -(POLARSSL_ERR_DES_INVALID_INPUT_LENGTH) )
614
        polarssl_snprintf( buf, buflen, "DES - The data input has an invalid length" );
615 616
#endif /* POLARSSL_DES_C */

617 618
#if defined(POLARSSL_ENTROPY_C)
    if( use_ret == -(POLARSSL_ERR_ENTROPY_SOURCE_FAILED) )
619
        polarssl_snprintf( buf, buflen, "ENTROPY - Critical entropy source failure" );
620
    if( use_ret == -(POLARSSL_ERR_ENTROPY_MAX_SOURCES) )
621
        polarssl_snprintf( buf, buflen, "ENTROPY - No more sources can be added" );
622
    if( use_ret == -(POLARSSL_ERR_ENTROPY_NO_SOURCES_DEFINED) )
623
        polarssl_snprintf( buf, buflen, "ENTROPY - No sources have been added to poll" );
624
    if( use_ret == -(POLARSSL_ERR_ENTROPY_FILE_IO_ERROR) )
625
        polarssl_snprintf( buf, buflen, "ENTROPY - Read/write error in file" );
626 627
#endif /* POLARSSL_ENTROPY_C */

628 629
#if defined(POLARSSL_GCM_C)
    if( use_ret == -(POLARSSL_ERR_GCM_AUTH_FAILED) )
630
        polarssl_snprintf( buf, buflen, "GCM - Authenticated decryption failed" );
Paul Bakker's avatar
Paul Bakker committed
631
    if( use_ret == -(POLARSSL_ERR_GCM_BAD_INPUT) )
632
        polarssl_snprintf( buf, buflen, "GCM - Bad input parameters to function" );
633 634
#endif /* POLARSSL_GCM_C */

635 636
#if defined(POLARSSL_HMAC_DRBG_C)
    if( use_ret == -(POLARSSL_ERR_HMAC_DRBG_REQUEST_TOO_BIG) )
637
        polarssl_snprintf( buf, buflen, "HMAC_DRBG - Too many random requested in single call" );
638
    if( use_ret == -(POLARSSL_ERR_HMAC_DRBG_INPUT_TOO_BIG) )
639
        polarssl_snprintf( buf, buflen, "HMAC_DRBG - Input too large (Entropy + additional)" );
640
    if( use_ret == -(POLARSSL_ERR_HMAC_DRBG_FILE_IO_ERROR) )
641
        polarssl_snprintf( buf, buflen, "HMAC_DRBG - Read/write error in file" );