LCOV - code coverage report
Current view: top level - lib - fko_funcs.c (source / functions) Hit Total Coverage
Test: lcov_coverage_final.info Lines: 220 224 98.2 %
Date: 2015-08-23 Functions: 10 10 100.0 %
Branches: 159 182 87.4 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  *****************************************************************************
       3                 :            :  *
       4                 :            :  * File:    fko_funcs.c
       5                 :            :  *
       6                 :            :  * Purpose: General utility functions for libfko
       7                 :            :  *
       8                 :            :  *  Fwknop is developed primarily by the people listed in the file 'AUTHORS'.
       9                 :            :  *  Copyright (C) 2009-2014 fwknop developers and contributors. For a full
      10                 :            :  *  list of contributors, see the file 'CREDITS'.
      11                 :            :  *
      12                 :            :  *  License (GNU General Public License):
      13                 :            :  *
      14                 :            :  *  This program is free software; you can redistribute it and/or
      15                 :            :  *  modify it under the terms of the GNU General Public License
      16                 :            :  *  as published by the Free Software Foundation; either version 2
      17                 :            :  *  of the License, or (at your option) any later version.
      18                 :            :  *
      19                 :            :  *  This program is distributed in the hope that it will be useful,
      20                 :            :  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
      21                 :            :  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      22                 :            :  *  GNU General Public License for more details.
      23                 :            :  *
      24                 :            :  *  You should have received a copy of the GNU General Public License
      25                 :            :  *  along with this program; if not, write to the Free Software
      26                 :            :  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
      27                 :            :  *  USA
      28                 :            :  *
      29                 :            :  *****************************************************************************
      30                 :            : */
      31                 :            : #include "fko_common.h"
      32                 :            : #include "fko.h"
      33                 :            : #include "cipher_funcs.h"
      34                 :            : #include "base64.h"
      35                 :            : #include "digest.h"
      36                 :            : 
      37                 :            : /* Initialize an fko context.
      38                 :            : */
      39                 :            : int
      40                 :     866822 : fko_new(fko_ctx_t *r_ctx)
      41                 :            : {
      42                 :     866822 :     fko_ctx_t   ctx = NULL;
      43                 :            :     int         res;
      44                 :            :     char       *ver;
      45                 :            : 
      46                 :            : #if HAVE_LIBFIU
      47         [ +  + ]:     866822 :     fiu_return_on("fko_new_calloc", FKO_ERROR_MEMORY_ALLOCATION);
      48                 :            : #endif
      49                 :            : 
      50                 :     866819 :     ctx = calloc(1, sizeof *ctx);
      51         [ +  + ]:     866819 :     if(ctx == NULL)
      52                 :            :         return(FKO_ERROR_MEMORY_ALLOCATION);
      53                 :            : 
      54                 :            :     /* Set default values and state.
      55                 :            :      *
      56                 :            :      * Note: We initialize the context early so that the fko_set_xxx
      57                 :            :      *       functions can operate properly. If there are any problems during
      58                 :            :      *       initialization, then fko_destroy() is called which will clean up
      59                 :            :      *       the context.
      60                 :            :     */
      61                 :     866749 :     ctx->initval = FKO_CTX_INITIALIZED;
      62                 :            : 
      63                 :            :     /* Set the version string.
      64                 :            :     */
      65                 :     866749 :     ver = strdup(FKO_PROTOCOL_VERSION);
      66         [ +  + ]:     866749 :     if(ver == NULL)
      67                 :            :     {
      68                 :         45 :         fko_destroy(ctx);
      69                 :         45 :         ctx = NULL;
      70                 :         45 :         return(FKO_ERROR_MEMORY_ALLOCATION);
      71                 :            :     }
      72                 :     866704 :     ctx->version = ver;
      73                 :            : 
      74                 :            :     /* Rand value.
      75                 :            :     */
      76                 :     866704 :     res = fko_set_rand_value(ctx, NULL);
      77         [ +  + ]:     866704 :     if(res != FKO_SUCCESS)
      78                 :            :     {
      79                 :        159 :         fko_destroy(ctx);
      80                 :        159 :         ctx = NULL;
      81                 :        159 :         return res;
      82                 :            :     }
      83                 :            : 
      84                 :            :     /* Username.
      85                 :            :     */
      86                 :     866545 :     res = fko_set_username(ctx, NULL);
      87         [ +  + ]:     866545 :     if(res != FKO_SUCCESS)
      88                 :            :     {
      89                 :         49 :         fko_destroy(ctx);
      90                 :         49 :         ctx = NULL;
      91                 :         49 :         return res;
      92                 :            :     }
      93                 :            : 
      94                 :            :     /* Timestamp.
      95                 :            :     */
      96                 :     866496 :     res = fko_set_timestamp(ctx, 0);
      97         [ +  + ]:     866496 :     if(res != FKO_SUCCESS)
      98                 :            :     {
      99                 :          6 :         fko_destroy(ctx);
     100                 :          6 :         ctx = NULL;
     101                 :          6 :         return res;
     102                 :            :     }
     103                 :            : 
     104                 :            :     /* Default Digest Type.
     105                 :            :     */
     106                 :     866490 :     res = fko_set_spa_digest_type(ctx, FKO_DEFAULT_DIGEST);
     107         [ +  + ]:     866490 :     if(res != FKO_SUCCESS)
     108                 :            :     {
     109                 :          6 :         fko_destroy(ctx);
     110                 :          6 :         ctx = NULL;
     111                 :          6 :         return res;
     112                 :            :     }
     113                 :            : 
     114                 :            :     /* Default Message Type.
     115                 :            :     */
     116                 :     866484 :     res = fko_set_spa_message_type(ctx, FKO_DEFAULT_MSG_TYPE);
     117         [ +  + ]:     866484 :     if(res != FKO_SUCCESS)
     118                 :            :     {
     119                 :          6 :         fko_destroy(ctx);
     120                 :          6 :         ctx = NULL;
     121                 :          6 :         return res;
     122                 :            :     }
     123                 :            : 
     124                 :            :     /* Default Encryption Type.
     125                 :            :     */
     126                 :     866478 :     res = fko_set_spa_encryption_type(ctx, FKO_DEFAULT_ENCRYPTION);
     127         [ +  + ]:     866478 :     if(res != FKO_SUCCESS)
     128                 :            :     {
     129                 :          6 :         fko_destroy(ctx);
     130                 :          6 :         ctx = NULL;
     131                 :          6 :         return res;
     132                 :            :     }
     133                 :            : 
     134                 :            :     /* Default is Rijndael in CBC mode
     135                 :            :     */
     136                 :     866472 :     res = fko_set_spa_encryption_mode(ctx, FKO_DEFAULT_ENC_MODE);
     137         [ +  + ]:     866472 :     if(res != FKO_SUCCESS)
     138                 :            :     {
     139                 :          6 :         fko_destroy(ctx);
     140                 :          6 :         ctx = NULL;
     141                 :          6 :         return res;
     142                 :            :     }
     143                 :            : 
     144                 :            : #if HAVE_LIBGPGME
     145                 :            :     /* Set gpg signature verify on.
     146                 :            :     */
     147                 :     866466 :     ctx->verify_gpg_sigs = 1;
     148                 :            : 
     149                 :            : #endif /* HAVE_LIBGPGME */
     150                 :            : 
     151                 :     866466 :     FKO_SET_CTX_INITIALIZED(ctx);
     152                 :            : 
     153                 :     866466 :     *r_ctx = ctx;
     154                 :            : 
     155                 :     866466 :     return(FKO_SUCCESS);
     156                 :            : }
     157                 :            : 
     158                 :            : /* Initialize an fko context with external (encrypted/encoded) data.
     159                 :            :  * This is used to create a context with the purpose of decoding
     160                 :            :  * and parsing the provided data into the context data.
     161                 :            : */
     162                 :            : int
     163                 :     787813 : fko_new_with_data(fko_ctx_t *r_ctx, const char * const enc_msg,
     164                 :            :     const char * const dec_key, const int dec_key_len,
     165                 :            :     int encryption_mode, const char * const hmac_key,
     166                 :            :     const int hmac_key_len, const int hmac_type)
     167                 :            : {
     168                 :     787813 :     fko_ctx_t   ctx = NULL;
     169                 :     787813 :     int         res = FKO_SUCCESS; /* Are we optimistic or what? */
     170                 :            :     int         enc_msg_len;
     171                 :            : 
     172                 :            : #if HAVE_LIBFIU
     173         [ +  + ]:     787813 :     fiu_return_on("fko_new_with_data_msg",
     174                 :            :             FKO_ERROR_INVALID_DATA_FUNCS_NEW_ENCMSG_MISSING);
     175                 :            : #endif
     176                 :            : 
     177         [ +  + ]:     787812 :     if(enc_msg == NULL)
     178                 :            :         return(FKO_ERROR_INVALID_DATA_FUNCS_NEW_ENCMSG_MISSING);
     179                 :            : 
     180                 :            : #if HAVE_LIBFIU
     181         [ +  + ]:     787806 :     fiu_return_on("fko_new_with_data_keylen",
     182                 :            :             FKO_ERROR_INVALID_KEY_LEN);
     183                 :            : #endif
     184                 :            : 
     185         [ +  - ]:     787805 :     if(dec_key_len < 0 || hmac_key_len < 0)
     186                 :            :         return(FKO_ERROR_INVALID_KEY_LEN);
     187                 :            : 
     188                 :     787805 :     ctx = calloc(1, sizeof *ctx);
     189         [ +  + ]:     787805 :     if(ctx == NULL)
     190                 :            :         return(FKO_ERROR_MEMORY_ALLOCATION);
     191                 :            : 
     192                 :     787694 :     enc_msg_len = strnlen(enc_msg, MAX_SPA_ENCODED_MSG_SIZE);
     193                 :            : 
     194         [ +  + ]:     787694 :     if(! is_valid_encoded_msg_len(enc_msg_len))
     195                 :            :     {
     196                 :          9 :         free(ctx);
     197                 :          9 :         return(FKO_ERROR_INVALID_DATA_FUNCS_NEW_MSGLEN_VALIDFAIL);
     198                 :            :     }
     199                 :            : 
     200                 :            :     /* First, add the data to the context.
     201                 :            :     */
     202                 :     787685 :     ctx->encrypted_msg     = strdup(enc_msg);
     203                 :     787685 :     ctx->encrypted_msg_len = enc_msg_len;
     204                 :            : 
     205         [ -  + ]:     787685 :     if(ctx->encrypted_msg == NULL)
     206                 :            :     {
     207                 :          0 :         free(ctx);
     208                 :          0 :         return(FKO_ERROR_MEMORY_ALLOCATION);
     209                 :            :     }
     210                 :            : 
     211                 :            :     /* Default Encryption Mode (Rijndael in CBC mode)
     212                 :            :     */
     213                 :     787685 :     ctx->initval = FKO_CTX_INITIALIZED;
     214                 :     787685 :     res = fko_set_spa_encryption_mode(ctx, encryption_mode);
     215         [ +  + ]:     787685 :     if(res != FKO_SUCCESS)
     216                 :            :     {
     217                 :          2 :         fko_destroy(ctx);
     218                 :          2 :         ctx = NULL;
     219                 :          2 :         return res;
     220                 :            :     }
     221                 :            : 
     222                 :            :     /* HMAC digest type
     223                 :            :     */
     224                 :     787683 :     res = fko_set_spa_hmac_type(ctx, hmac_type);
     225         [ +  + ]:     787683 :     if(res != FKO_SUCCESS)
     226                 :            :     {
     227                 :          2 :         fko_destroy(ctx);
     228                 :          2 :         ctx = NULL;
     229                 :          2 :         return res;
     230                 :            :     }
     231                 :            : 
     232                 :            :     /* Check HMAC if the access stanza had an HMAC key
     233                 :            :     */
     234         [ +  + ]:     787681 :     if(hmac_key_len > 0 && hmac_key != NULL)
     235                 :     769994 :         res = fko_verify_hmac(ctx, hmac_key, hmac_key_len);
     236         [ +  + ]:     787681 :     if(res != FKO_SUCCESS)
     237                 :            :     {
     238                 :       2340 :         fko_destroy(ctx);
     239                 :       2340 :         ctx = NULL;
     240                 :       2340 :         return res;
     241                 :            :     }
     242                 :            : 
     243                 :            :     /* Consider it initialized here.
     244                 :            :     */
     245                 :     785341 :     FKO_SET_CTX_INITIALIZED(ctx);
     246                 :            : 
     247                 :            :     /* If a decryption key is provided, go ahead and decrypt and decode.
     248                 :            :     */
     249         [ +  + ]:     785341 :     if(dec_key != NULL)
     250                 :            :     {
     251                 :     765926 :         res = fko_decrypt_spa_data(ctx, dec_key, dec_key_len);
     252                 :            : 
     253         [ +  + ]:     765926 :         if(res != FKO_SUCCESS)
     254                 :            :         {
     255                 :     725565 :             fko_destroy(ctx);
     256                 :     725565 :             ctx = NULL;
     257                 :     725565 :             *r_ctx = NULL; /* Make sure the caller ctx is null just in case */
     258                 :     725565 :             return(res);
     259                 :            :         }
     260                 :            :     }
     261                 :            : 
     262                 :            : #if HAVE_LIBGPGME
     263                 :            :     /* Set gpg signature verify on.
     264                 :            :     */
     265                 :      59776 :     ctx->verify_gpg_sigs = 1;
     266                 :            : 
     267                 :            : #endif /* HAVE_LIBGPGME */
     268                 :            : 
     269                 :      59776 :     *r_ctx = ctx;
     270                 :            : 
     271                 :      59776 :     return(res);
     272                 :            : }
     273                 :            : 
     274                 :            : /* Destroy a context and free its resources
     275                 :            : */
     276                 :            : int
     277                 :    2377372 : fko_destroy(fko_ctx_t ctx)
     278                 :            : {
     279                 :    2377372 :     int zero_free_rv = FKO_SUCCESS;
     280                 :            : 
     281                 :            : #if HAVE_LIBGPGME
     282                 :            :     fko_gpg_sig_t   gsig, tgsig;
     283                 :            : #endif
     284                 :            : 
     285 [ +  + ][ +  - ]:    2377372 :     if(!CTX_INITIALIZED(ctx))
     286                 :            :         return(zero_free_rv);
     287                 :            : 
     288         [ +  + ]:    1654434 :     if(ctx->rand_val != NULL)
     289                 :    1187421 :         free(ctx->rand_val);
     290                 :            : 
     291         [ +  + ]:    1654434 :     if(ctx->username != NULL)
     292                 :    1181400 :         free(ctx->username);
     293                 :            : 
     294         [ +  + ]:    1654434 :     if(ctx->version != NULL)
     295                 :    1080659 :         free(ctx->version);
     296                 :            : 
     297         [ +  + ]:    1654434 :     if(ctx->message != NULL)
     298                 :     496454 :         free(ctx->message);
     299                 :            : 
     300         [ +  + ]:    1654434 :     if(ctx->nat_access != NULL)
     301                 :     193640 :         free(ctx->nat_access);
     302                 :            : 
     303         [ +  + ]:    1654434 :     if(ctx->server_auth != NULL)
     304                 :      61375 :         free(ctx->server_auth);
     305                 :            : 
     306         [ +  + ]:    1654434 :     if(ctx->digest != NULL)
     307         [ -  + ]:    1132555 :         if(zero_free(ctx->digest, ctx->digest_len) != FKO_SUCCESS)
     308                 :          0 :             zero_free_rv = FKO_ERROR_ZERO_OUT_DATA;
     309                 :            : 
     310         [ +  + ]:    1654434 :     if(ctx->raw_digest != NULL)
     311         [ +  + ]:      16926 :         if(zero_free(ctx->raw_digest, ctx->raw_digest_len) != FKO_SUCCESS)
     312                 :          2 :             zero_free_rv = FKO_ERROR_ZERO_OUT_DATA;
     313                 :            : 
     314         [ +  + ]:    1654434 :     if(ctx->encoded_msg != NULL)
     315         [ +  + ]:    1401156 :         if(zero_free(ctx->encoded_msg, ctx->encoded_msg_len) != FKO_SUCCESS)
     316                 :      51296 :             zero_free_rv = FKO_ERROR_ZERO_OUT_DATA;
     317                 :            : 
     318         [ +  + ]:    1654434 :     if(ctx->encrypted_msg != NULL)
     319         [ +  + ]:    1588963 :         if(zero_free(ctx->encrypted_msg, ctx->encrypted_msg_len) != FKO_SUCCESS)
     320                 :          4 :             zero_free_rv = FKO_ERROR_ZERO_OUT_DATA;
     321                 :            : 
     322         [ +  + ]:    1654434 :     if(ctx->msg_hmac != NULL)
     323         [ +  + ]:    1521610 :         if(zero_free(ctx->msg_hmac, ctx->msg_hmac_len) != FKO_SUCCESS)
     324                 :          2 :             zero_free_rv = FKO_ERROR_ZERO_OUT_DATA;
     325                 :            : 
     326                 :            : #if HAVE_LIBGPGME
     327         [ +  + ]:    1654434 :     if(ctx->gpg_exe != NULL)
     328                 :          2 :         free(ctx->gpg_exe);
     329                 :            : 
     330         [ +  + ]:    1654434 :     if(ctx->gpg_home_dir != NULL)
     331                 :        147 :         free(ctx->gpg_home_dir);
     332                 :            : 
     333         [ +  + ]:    1654434 :     if(ctx->gpg_recipient != NULL)
     334                 :         78 :         free(ctx->gpg_recipient);
     335                 :            : 
     336         [ +  + ]:    1654434 :     if(ctx->gpg_signer != NULL)
     337                 :         77 :         free(ctx->gpg_signer);
     338                 :            : 
     339         [ +  + ]:    1654434 :     if(ctx->recipient_key != NULL)
     340                 :         78 :         gpgme_key_unref(ctx->recipient_key);
     341                 :            : 
     342         [ +  + ]:    1654434 :     if(ctx->signer_key != NULL)
     343                 :         77 :         gpgme_key_unref(ctx->signer_key);
     344                 :            : 
     345         [ +  + ]:    1654434 :     if(ctx->gpg_ctx != NULL)
     346                 :        140 :         gpgme_release(ctx->gpg_ctx);
     347                 :            : 
     348                 :    1654434 :     gsig = ctx->gpg_sigs;
     349         [ +  + ]:    1654494 :     while(gsig != NULL)
     350                 :            :     {
     351         [ +  - ]:         60 :         if(gsig->fpr != NULL)
     352                 :         60 :             free(gsig->fpr);
     353                 :            : 
     354                 :         60 :         tgsig = gsig;
     355                 :         60 :         gsig = gsig->next;
     356                 :            : 
     357                 :         60 :         free(tgsig);
     358                 :            :     }
     359                 :            : 
     360                 :            : #endif /* HAVE_LIBGPGME */
     361                 :            : 
     362                 :            :     memset(ctx, 0x0, sizeof(*ctx));
     363                 :            : 
     364                 :    1654434 :     free(ctx);
     365                 :            : 
     366                 :    1654434 :     return(zero_free_rv);
     367                 :            : }
     368                 :            : 
     369                 :            : /* Generate Rijndael and HMAC keys from /dev/random and base64
     370                 :            :  * encode them
     371                 :            : */
     372                 :            : int
     373                 :        217 : fko_key_gen(char * const key_base64, const int key_len,
     374                 :            :         char * const hmac_key_base64, const int hmac_key_len,
     375                 :            :         const int hmac_type)
     376                 :            : {
     377                 :            :     unsigned char key[RIJNDAEL_MAX_KEYSIZE];
     378                 :            :     unsigned char hmac_key[SHA512_BLOCK_LEN];
     379                 :        217 :     int klen      = key_len;
     380                 :        217 :     int hmac_klen = hmac_key_len;
     381                 :        217 :     int b64_len   = 0;
     382                 :            : 
     383         [ +  - ]:        217 :     if(key_len == FKO_DEFAULT_KEY_LEN)
     384                 :        217 :         klen = RIJNDAEL_MAX_KEYSIZE;
     385                 :            : 
     386         [ +  - ]:        217 :     if(hmac_key_len == FKO_DEFAULT_KEY_LEN)
     387                 :            :     {
     388         [ +  + ]:        217 :         if(hmac_type == FKO_DEFAULT_HMAC_MODE
     389                 :            :                 || hmac_type == FKO_HMAC_SHA256)
     390                 :            :             hmac_klen = SHA256_BLOCK_LEN;
     391         [ +  + ]:          4 :         else if(hmac_type == FKO_HMAC_MD5)
     392                 :            :             hmac_klen = MD5_DIGEST_LEN;
     393         [ +  + ]:          3 :         else if(hmac_type == FKO_HMAC_SHA1)
     394                 :            :             hmac_klen = SHA1_DIGEST_LEN;
     395         [ +  + ]:          2 :         else if(hmac_type == FKO_HMAC_SHA384)
     396                 :            :             hmac_klen = SHA384_BLOCK_LEN;
     397         [ +  - ]:          1 :         else if(hmac_type == FKO_HMAC_SHA512)
     398                 :          1 :             hmac_klen = SHA512_BLOCK_LEN;
     399                 :            :     }
     400                 :            : 
     401         [ +  - ]:        217 :     if((klen < 1) || (klen > RIJNDAEL_MAX_KEYSIZE))
     402                 :            :         return(FKO_ERROR_INVALID_DATA_FUNCS_GEN_KEYLEN_VALIDFAIL);
     403                 :            : 
     404         [ +  - ]:        217 :     if((hmac_klen < 1) || (hmac_klen > SHA512_BLOCK_LEN))
     405                 :            :         return(FKO_ERROR_INVALID_DATA_FUNCS_GEN_HMACLEN_VALIDFAIL);
     406                 :            : 
     407                 :        217 :     get_random_data(key, klen);
     408                 :        217 :     get_random_data(hmac_key, hmac_klen);
     409                 :            : 
     410                 :        217 :     b64_len = b64_encode(key, key_base64, klen);
     411         [ +  - ]:        217 :     if(b64_len < klen)
     412                 :            :         return(FKO_ERROR_INVALID_DATA_FUNCS_GEN_KEY_ENCODEFAIL);
     413                 :            : 
     414                 :        217 :     b64_len = b64_encode(hmac_key, hmac_key_base64, hmac_klen);
     415         [ +  - ]:        217 :     if(b64_len < hmac_klen)
     416                 :            :         return(FKO_ERROR_INVALID_DATA_FUNCS_GEN_HMAC_ENCODEFAIL);
     417                 :            : 
     418                 :        217 :     return(FKO_SUCCESS);
     419                 :            : }
     420                 :            : 
     421                 :            : /* Provide an FKO wrapper around base64 encode/decode functions
     422                 :            : */
     423                 :            : int
     424                 :          8 : fko_base64_encode(unsigned char * const in, char * const out, int in_len)
     425                 :            : {
     426                 :          8 :     return b64_encode(in, out, in_len);
     427                 :            : }
     428                 :            : 
     429                 :            : int
     430                 :     847412 : fko_base64_decode(const char * const in, unsigned char *out)
     431                 :            : {
     432                 :     847412 :     return b64_decode(in, out);
     433                 :            : }
     434                 :            : 
     435                 :            : /* Return the fko version
     436                 :            : */
     437                 :            : int
     438                 :       4525 : fko_get_version(fko_ctx_t ctx, char **version)
     439                 :            : {
     440                 :            : 
     441                 :            : #if HAVE_LIBFIU
     442         [ +  + ]:       4525 :     fiu_return_on("fko_get_version_init", FKO_ERROR_CTX_NOT_INITIALIZED);
     443                 :            : #endif
     444                 :            : 
     445                 :            :     /* Must be initialized
     446                 :            :     */
     447 [ +  + ][ +  - ]:       4523 :     if(!CTX_INITIALIZED(ctx))
     448                 :            :         return(FKO_ERROR_CTX_NOT_INITIALIZED);
     449                 :            : 
     450         [ +  + ]:       4371 :     if(version == NULL)
     451                 :            :         return(FKO_ERROR_INVALID_DATA);
     452                 :            : 
     453                 :            : #if HAVE_LIBFIU
     454         [ +  + ]:       4303 :     fiu_return_on("fko_get_version_val", FKO_ERROR_INVALID_DATA);
     455                 :            : #endif
     456                 :            : 
     457                 :       4301 :     *version = ctx->version;
     458                 :            : 
     459                 :       4301 :     return(FKO_SUCCESS);
     460                 :            : }
     461                 :            : 
     462                 :            : /* Final update and encoding of data in the context.
     463                 :            :  * This does require all requisite fields be properly
     464                 :            :  * set.
     465                 :            : */
     466                 :            : int
     467                 :     881533 : fko_spa_data_final(fko_ctx_t ctx,
     468                 :            :     const char * const enc_key, const int enc_key_len,
     469                 :            :     const char * const hmac_key, const int hmac_key_len)
     470                 :            : {
     471                 :            :     char   *tbuf;
     472                 :     881533 :     int     res = 0, data_with_hmac_len = 0;
     473                 :            : 
     474                 :            :     /* Must be initialized
     475                 :            :     */
     476 [ +  + ][ +  - ]:     881533 :     if(!CTX_INITIALIZED(ctx))
     477                 :            :         return(FKO_ERROR_CTX_NOT_INITIALIZED);
     478                 :            : 
     479         [ +  + ]:     874323 :     if(enc_key_len < 0)
     480                 :            :         return(FKO_ERROR_INVALID_KEY_LEN);
     481                 :            : 
     482                 :     866583 :     res = fko_encrypt_spa_data(ctx, enc_key, enc_key_len);
     483                 :            : 
     484                 :            :     /* Now calculate hmac if so configured
     485                 :            :     */
     486 [ +  + ][ +  + ]:     866583 :     if (res == FKO_SUCCESS && ctx->hmac_type != FKO_HMAC_UNKNOWN)
     487                 :            :     {
     488         [ +  + ]:     755158 :         if(hmac_key_len < 0)
     489                 :            :             return(FKO_ERROR_INVALID_KEY_LEN);
     490                 :            : 
     491         [ +  + ]:     754548 :         if(hmac_key == NULL)
     492                 :            :             return(FKO_ERROR_INVALID_KEY_LEN);
     493                 :            : 
     494                 :     754388 :         res = fko_set_spa_hmac(ctx, hmac_key, hmac_key_len);
     495                 :            : 
     496         [ +  + ]:     754388 :         if (res == FKO_SUCCESS)
     497                 :            :         {
     498                 :            :             /* Now that we have the hmac, append it to the
     499                 :            :              * encrypted data (which has already been base64-encoded
     500                 :            :              * and the trailing '=' chars stripped off).
     501                 :            :             */
     502                 :            :             data_with_hmac_len
     503                 :     754326 :                 = ctx->encrypted_msg_len+1+ctx->msg_hmac_len+1;
     504                 :            : 
     505                 :     754326 :             tbuf = realloc(ctx->encrypted_msg, data_with_hmac_len);
     506         [ +  - ]:     754326 :             if (tbuf == NULL)
     507                 :            :                 return(FKO_ERROR_MEMORY_ALLOCATION);
     508                 :            : 
     509                 :     754326 :             strlcat(tbuf, ctx->msg_hmac, data_with_hmac_len);
     510                 :            : 
     511                 :     754326 :             ctx->encrypted_msg     = tbuf;
     512                 :     754326 :             ctx->encrypted_msg_len = data_with_hmac_len;
     513                 :            :         }
     514                 :            :     }
     515                 :            : 
     516                 :     865813 :     return res;
     517                 :            : }
     518                 :            : 
     519                 :            : /* Return the fko SPA encrypted data.
     520                 :            : */
     521                 :            : int
     522                 :     759339 : fko_get_spa_data(fko_ctx_t ctx, char **spa_data)
     523                 :            : {
     524                 :            : 
     525                 :            : #if HAVE_LIBFIU
     526         [ +  - ]:     759339 :     fiu_return_on("fko_get_spa_data_init", FKO_ERROR_CTX_NOT_INITIALIZED);
     527                 :            : #endif
     528                 :            : 
     529                 :            :     /* Must be initialized
     530                 :            :     */
     531 [ +  + ][ +  - ]:     759339 :     if(!CTX_INITIALIZED(ctx))
     532                 :            :         return(FKO_ERROR_CTX_NOT_INITIALIZED);
     533                 :            : 
     534         [ +  + ]:     759177 :     if(spa_data == NULL)
     535                 :            :         return(FKO_ERROR_INVALID_DATA);
     536                 :            : 
     537                 :            : #if HAVE_LIBFIU
     538         [ +  - ]:     759109 :     fiu_return_on("fko_get_spa_data_val", FKO_ERROR_INVALID_DATA);
     539                 :            : #endif
     540                 :            : 
     541                 :            :     /* We expect to have encrypted data to process.  If not, we bail.
     542                 :            :     */
     543   [ +  +  +  - ]:    1518150 :     if(ctx->encrypted_msg == NULL || ! is_valid_encoded_msg_len(
     544                 :     759041 :                 strnlen(ctx->encrypted_msg, MAX_SPA_ENCODED_MSG_SIZE)))
     545                 :            :         return(FKO_ERROR_MISSING_ENCODED_DATA);
     546                 :            : 
     547                 :            : #if HAVE_LIBFIU
     548         [ +  - ]:     759041 :     fiu_return_on("fko_get_spa_data_encoded", FKO_ERROR_MISSING_ENCODED_DATA);
     549                 :            : #endif
     550                 :            : 
     551                 :     759041 :     *spa_data = ctx->encrypted_msg;
     552                 :            : 
     553                 :            :     /* Notice we omit the first 10 bytes if Rijndael encryption is
     554                 :            :      * used (to eliminate the consistent 'Salted__' string), and
     555                 :            :      * in GnuPG mode we eliminate the consistent 'hQ' base64 encoded
     556                 :            :      * prefix
     557                 :            :     */
     558         [ +  + ]:     759041 :     if(ctx->encryption_type == FKO_ENCRYPTION_RIJNDAEL)
     559                 :     758821 :         *spa_data += B64_RIJNDAEL_SALT_STR_LEN;
     560         [ +  + ]:        220 :     else if(ctx->encryption_type == FKO_ENCRYPTION_GPG)
     561                 :        218 :         *spa_data += B64_GPG_PREFIX_STR_LEN;
     562                 :            : 
     563                 :            :     return(FKO_SUCCESS);
     564                 :            : }
     565                 :            : 
     566                 :            : /* Set the fko SPA encrypted data.
     567                 :            : */
     568                 :            : int
     569                 :       4510 : fko_set_spa_data(fko_ctx_t ctx, const char * const enc_msg)
     570                 :            : {
     571                 :            :     int         enc_msg_len;
     572                 :            : 
     573                 :            :     /* Must be initialized
     574                 :            :     */
     575 [ +  + ][ +  - ]:       4510 :     if(!CTX_INITIALIZED(ctx))
     576                 :            :         return FKO_ERROR_CTX_NOT_INITIALIZED;
     577                 :            : 
     578         [ +  + ]:       4506 :     if(enc_msg == NULL)
     579                 :            :         return(FKO_ERROR_INVALID_DATA_FUNCS_SET_MSGLEN_VALIDFAIL);
     580                 :            : 
     581                 :       4494 :     enc_msg_len = strnlen(enc_msg, MAX_SPA_ENCODED_MSG_SIZE);
     582                 :            : 
     583         [ +  + ]:       4494 :     if(! is_valid_encoded_msg_len(enc_msg_len))
     584                 :            :         return(FKO_ERROR_INVALID_DATA_FUNCS_SET_MSGLEN_VALIDFAIL);
     585                 :            : 
     586         [ -  + ]:       4400 :     if(ctx->encrypted_msg != NULL)
     587                 :          0 :         free(ctx->encrypted_msg);
     588                 :            : 
     589                 :            :     /* First, add the data to the context.
     590                 :            :     */
     591                 :       4400 :     ctx->encrypted_msg = strdup(enc_msg);
     592                 :       4400 :     ctx->encrypted_msg_len = enc_msg_len;
     593                 :            : 
     594         [ +  - ]:       4400 :     if(ctx->encrypted_msg == NULL)
     595                 :            :         return(FKO_ERROR_MEMORY_ALLOCATION);
     596                 :            : 
     597                 :       4400 :     return(FKO_SUCCESS);
     598                 :            : }
     599                 :            : 
     600                 :            : #if AFL_FUZZING
     601                 :            : /* provide a way to set the encrypted data directly without base64 encoding.
     602                 :            :  * This allows direct AFL fuzzing against decryption routines.
     603                 :            : */
     604                 :            : int
     605                 :            : fko_afl_set_spa_data(fko_ctx_t ctx, const char * const enc_msg, const int enc_msg_len)
     606                 :            : {
     607                 :            :     /* Must be initialized
     608                 :            :     */
     609                 :            :     if(!CTX_INITIALIZED(ctx))
     610                 :            :         return FKO_ERROR_CTX_NOT_INITIALIZED;
     611                 :            : 
     612                 :            :     if(enc_msg == NULL)
     613                 :            :         return(FKO_ERROR_INVALID_DATA_FUNCS_SET_MSGLEN_VALIDFAIL);
     614                 :            : 
     615                 :            :     if(! is_valid_encoded_msg_len(enc_msg_len))
     616                 :            :         return(FKO_ERROR_INVALID_DATA_FUNCS_SET_MSGLEN_VALIDFAIL);
     617                 :            : 
     618                 :            :     if(ctx->encrypted_msg != NULL)
     619                 :            :         free(ctx->encrypted_msg);
     620                 :            : 
     621                 :            :     /* Copy the raw encrypted data into the context
     622                 :            :     */
     623                 :            :     ctx->encrypted_msg = calloc(1, enc_msg_len);
     624                 :            :     if(ctx->encrypted_msg == NULL)
     625                 :            :         return(FKO_ERROR_MEMORY_ALLOCATION);
     626                 :            : 
     627                 :            :     memcpy(ctx->encrypted_msg, enc_msg, enc_msg_len);
     628                 :            : 
     629                 :            :     ctx->encrypted_msg_len = enc_msg_len;
     630                 :            : 
     631                 :            :     return(FKO_SUCCESS);
     632                 :            : }
     633                 :            : #endif
     634                 :            : 
     635                 :            : /***EOF***/

Generated by: LCOV version 1.10