LCOV - code coverage report
Current view: top level - lib - fko_digest.c (source / functions) Hit Total Coverage
Test: lcov_coverage_final.info Lines: 97 97 100.0 %
Date: 2016-06-07 Functions: 10 10 100.0 %
Branches: 78 94 83.0 %

           Branch data     Line data    Source code
       1                 :            : /**
       2                 :            :  * \file lib/fko_digest.c
       3                 :            :  *
       4                 :            :  * \brief Create the base64-encoded digest for the current spa data. The
       5                 :            :  *          digest used is determined by the digest_type setting in the
       6                 :            :  *          fko context.
       7                 :            :  */
       8                 :            : 
       9                 :            : /*  Fwknop is developed primarily by the people listed in the file 'AUTHORS'.
      10                 :            :  *  Copyright (C) 2009-2015 fwknop developers and contributors. For a full
      11                 :            :  *  list of contributors, see the file 'CREDITS'.
      12                 :            :  *
      13                 :            :  *  License (GNU General Public License):
      14                 :            :  *
      15                 :            :  *  This program is free software; you can redistribute it and/or
      16                 :            :  *  modify it under the terms of the GNU General Public License
      17                 :            :  *  as published by the Free Software Foundation; either version 2
      18                 :            :  *  of the License, or (at your option) any later version.
      19                 :            :  *
      20                 :            :  *  This program is distributed in the hope that it will be useful,
      21                 :            :  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
      22                 :            :  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      23                 :            :  *  GNU General Public License for more details.
      24                 :            :  *
      25                 :            :  *  You should have received a copy of the GNU General Public License
      26                 :            :  *  along with this program; if not, write to the Free Software
      27                 :            :  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
      28                 :            :  *  USA
      29                 :            :  *
      30                 :            :  *****************************************************************************
      31                 :            : */
      32                 :            : #include "fko_common.h"
      33                 :            : #include "fko.h"
      34                 :            : #include "digest.h"
      35                 :            : 
      36                 :            : /* Set the SPA digest type.
      37                 :            : */
      38                 :            : static int
      39                 :    1738753 : set_spa_digest_type(fko_ctx_t ctx,
      40                 :            :     short *digest_type_field, const short digest_type)
      41                 :            : {
      42                 :            : #if HAVE_LIBFIU
      43         [ +  + ]:    1738753 :     fiu_return_on("set_spa_digest_type_init", FKO_ERROR_CTX_NOT_INITIALIZED);
      44                 :            : #endif
      45                 :            :     /* Must be initialized
      46                 :            :     */
      47 [ +  + ][ +  - ]:    1738749 :     if(!CTX_INITIALIZED(ctx))
      48                 :            :         return(FKO_ERROR_CTX_NOT_INITIALIZED);
      49                 :            : 
      50                 :            : #if HAVE_LIBFIU
      51         [ +  + ]:    1737045 :     fiu_return_on("set_spa_digest_type_val",
      52                 :            :             FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_VALIDFAIL);
      53                 :            : #endif
      54         [ +  + ]:    1737041 :     if(digest_type < 1 || digest_type >= FKO_LAST_DIGEST_TYPE)
      55                 :            :         return(FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_VALIDFAIL);
      56                 :            : 
      57                 :    1728829 :     *digest_type_field = digest_type;
      58                 :            : 
      59                 :    1728829 :     ctx->state |= FKO_DIGEST_TYPE_MODIFIED;
      60                 :            : 
      61                 :    1728829 :     return(FKO_SUCCESS);
      62                 :            : }
      63                 :            : 
      64                 :            : int
      65                 :    1722734 : fko_set_spa_digest_type(fko_ctx_t ctx, const short digest_type)
      66                 :            : {
      67                 :    1722734 :     return set_spa_digest_type(ctx, &ctx->digest_type, digest_type);
      68                 :            : }
      69                 :            : 
      70                 :            : int
      71                 :      16019 : fko_set_raw_spa_digest_type(fko_ctx_t ctx, const short raw_digest_type)
      72                 :            : {
      73                 :      16019 :     return set_spa_digest_type(ctx, &ctx->raw_digest_type, raw_digest_type);
      74                 :            : }
      75                 :            : 
      76                 :            : /* Return the SPA digest type.
      77                 :            : */
      78                 :            : int
      79                 :       7299 : fko_get_spa_digest_type(fko_ctx_t ctx, short *digest_type)
      80                 :            : {
      81                 :            : #if HAVE_LIBFIU
      82         [ +  + ]:       7299 :     fiu_return_on("fko_get_spa_digest_type_init",
      83                 :            :             FKO_ERROR_CTX_NOT_INITIALIZED);
      84                 :            : #endif
      85                 :            :     /* Must be initialized
      86                 :            :     */
      87 [ +  + ][ +  - ]:       7298 :     if(!CTX_INITIALIZED(ctx))
      88                 :            :         return(FKO_ERROR_CTX_NOT_INITIALIZED);
      89                 :            : 
      90                 :            : #if HAVE_LIBFIU
      91         [ +  + ]:       6306 :     fiu_return_on("fko_get_spa_digest_type_val",
      92                 :            :             FKO_ERROR_INVALID_DATA);
      93                 :            : #endif
      94                 :            : 
      95         [ +  + ]:       6305 :     if(digest_type == NULL)
      96                 :            :         return(FKO_ERROR_INVALID_DATA);
      97                 :            : 
      98                 :       6237 :     *digest_type = ctx->digest_type;
      99                 :            : 
     100                 :       6237 :     return(FKO_SUCCESS);
     101                 :            : }
     102                 :            : 
     103                 :            : /* Return the SPA digest type.
     104                 :            : */
     105                 :            : int
     106                 :      15985 : fko_get_raw_spa_digest_type(fko_ctx_t ctx, short *raw_digest_type)
     107                 :            : {
     108                 :            : #if HAVE_LIBFIU
     109         [ +  + ]:      15985 :     fiu_return_on("fko_get_raw_spa_digest_type_init",
     110                 :            :             FKO_ERROR_CTX_NOT_INITIALIZED);
     111                 :            : #endif
     112                 :            :     /* Must be initialized
     113                 :            :     */
     114 [ +  - ][ +  - ]:      15984 :     if(!CTX_INITIALIZED(ctx))
     115                 :            :         return(FKO_ERROR_CTX_NOT_INITIALIZED);
     116                 :            : 
     117                 :      15984 :     *raw_digest_type = ctx->raw_digest_type;
     118                 :            : 
     119                 :      15984 :     return(FKO_SUCCESS);
     120                 :            : }
     121                 :            : 
     122                 :            : static int
     123                 :     865079 : set_digest(char *data, char **digest, short digest_type, int *digest_len)
     124                 :            : {
     125                 :     865079 :     char    *md = NULL;
     126                 :            :     int     data_len;
     127                 :            : 
     128                 :     865079 :     data_len = strnlen(data, MAX_SPA_ENCODED_MSG_SIZE);
     129                 :            : 
     130                 :            : #if HAVE_LIBFIU
     131         [ +  + ]:     865079 :     fiu_return_on("set_digest_toobig",
     132                 :            :             FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_TOOBIG);
     133                 :            : #endif
     134                 :            : 
     135         [ +  + ]:     865078 :     if(data_len == MAX_SPA_ENCODED_MSG_SIZE)
     136                 :            :         return(FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_TOOBIG);
     137                 :            : 
     138                 :            : #if HAVE_LIBFIU
     139         [ +  + ]:     820070 :     fiu_return_on("set_digest_invalidtype", FKO_ERROR_INVALID_DIGEST_TYPE);
     140         [ +  + ]:     820069 :     fiu_return_on("set_digest_calloc", FKO_ERROR_MEMORY_ALLOCATION);
     141                 :            : #endif
     142                 :            : 
     143   [ +  +  +  +  :     820068 :     switch(digest_type)
             +  +  +  + ]
     144                 :            :     {
     145                 :            :         case FKO_DIGEST_MD5:
     146                 :         31 :             md = calloc(1, MD_HEX_SIZE(MD5_DIGEST_LEN)+1);
     147         [ +  - ]:         31 :             if(md == NULL)
     148                 :            :                 return(FKO_ERROR_MEMORY_ALLOCATION);
     149                 :            : 
     150                 :         31 :             md5_base64(md,
     151                 :            :                 (unsigned char*)data, data_len);
     152                 :         31 :             *digest_len = MD5_B64_LEN;
     153                 :         31 :             break;
     154                 :            : 
     155                 :            :         case FKO_DIGEST_SHA1:
     156                 :         41 :             md = calloc(1, MD_HEX_SIZE(SHA1_DIGEST_LEN)+1);
     157         [ +  - ]:         41 :             if(md == NULL)
     158                 :            :                 return(FKO_ERROR_MEMORY_ALLOCATION);
     159                 :            : 
     160                 :         41 :             sha1_base64(md,
     161                 :            :                 (unsigned char*)data, data_len);
     162                 :         41 :             *digest_len = SHA1_B64_LEN;
     163                 :         41 :             break;
     164                 :            : 
     165                 :            :         case FKO_DIGEST_SHA256:
     166                 :     819864 :             md = calloc(1, MD_HEX_SIZE(SHA256_DIGEST_LEN)+1);
     167         [ +  + ]:     819864 :             if(md == NULL)
     168                 :            :                 return(FKO_ERROR_MEMORY_ALLOCATION);
     169                 :            : 
     170                 :     819830 :             sha256_base64(md,
     171                 :            :                 (unsigned char*)data, data_len);
     172                 :     819830 :             *digest_len = SHA256_B64_LEN;
     173                 :     819830 :             break;
     174                 :            : 
     175                 :            :         case FKO_DIGEST_SHA384:
     176                 :         28 :             md = calloc(1, MD_HEX_SIZE(SHA384_DIGEST_LEN)+1);
     177         [ +  - ]:         28 :             if(md == NULL)
     178                 :            :                 return(FKO_ERROR_MEMORY_ALLOCATION);
     179                 :            : 
     180                 :         28 :             sha384_base64(md,
     181                 :            :                 (unsigned char*)data, data_len);
     182                 :         28 :             *digest_len = SHA384_B64_LEN;
     183                 :         28 :             break;
     184                 :            : 
     185                 :            :         case FKO_DIGEST_SHA512:
     186                 :         30 :             md = calloc(1, MD_HEX_SIZE(SHA512_DIGEST_LEN)+1);
     187         [ +  - ]:         30 :             if(md == NULL)
     188                 :            :                 return(FKO_ERROR_MEMORY_ALLOCATION);
     189                 :            : 
     190                 :         30 :             sha512_base64(md,
     191                 :            :                 (unsigned char*)data, data_len);
     192                 :         30 :             *digest_len = SHA512_B64_LEN;
     193                 :         30 :             break;
     194                 :            : 
     195                 :            :         case FKO_DIGEST_SHA3_256:
     196                 :         21 :             md = calloc(1, MD_HEX_SIZE(SHA3_256_DIGEST_LEN)+1);
     197         [ +  - ]:         21 :             if(md == NULL)
     198                 :            :                 return(FKO_ERROR_MEMORY_ALLOCATION);
     199                 :            : 
     200                 :         21 :             sha3_256_base64(md,
     201                 :            :                 (unsigned char*)data, data_len);
     202                 :         21 :             *digest_len = SHA3_256_B64_LEN;
     203                 :         21 :             break;
     204                 :            : 
     205                 :            :         case FKO_DIGEST_SHA3_512:
     206                 :         37 :             md = calloc(1, MD_HEX_SIZE(SHA3_512_DIGEST_LEN)+1);
     207         [ +  - ]:         37 :             if(md == NULL)
     208                 :            :                 return(FKO_ERROR_MEMORY_ALLOCATION);
     209                 :            : 
     210                 :         37 :             sha3_512_base64(md,
     211                 :            :                 (unsigned char*)data, data_len);
     212                 :         37 :             *digest_len = SHA3_512_B64_LEN;
     213                 :         37 :             break;
     214                 :            : 
     215                 :            :         default:
     216                 :            :             return(FKO_ERROR_INVALID_DIGEST_TYPE);
     217                 :            :     }
     218                 :            : 
     219                 :            :     /* Just in case this is a subsequent call to this function.  We
     220                 :            :      * do not want to be leaking memory.
     221                 :            :     */
     222         [ +  + ]:     820018 :     if(*digest != NULL)
     223                 :        418 :         free(*digest);
     224                 :            : 
     225                 :     820018 :     *digest = md;
     226                 :            : 
     227                 :     820018 :     return(FKO_SUCCESS);
     228                 :            : }
     229                 :            : 
     230                 :            : int
     231                 :     850786 : fko_set_spa_digest(fko_ctx_t ctx)
     232                 :            : {
     233                 :            : #if HAVE_LIBFIU
     234         [ +  + ]:     850786 :     fiu_return_on("fko_set_spa_digest_init", FKO_ERROR_CTX_NOT_INITIALIZED);
     235                 :            : #endif
     236                 :            :     /* Must be initialized
     237                 :            :     */
     238 [ +  + ][ +  - ]:     850785 :     if(!CTX_INITIALIZED(ctx))
     239                 :            :         return(FKO_ERROR_CTX_NOT_INITIALIZED);
     240                 :            : 
     241                 :            :     /* Must have encoded message data to start with.
     242                 :            :     */
     243         [ +  + ]:     850357 :     if(ctx->encoded_msg == NULL)
     244                 :            :         return(FKO_ERROR_MISSING_ENCODED_DATA);
     245                 :            : 
     246                 :            : #if HAVE_LIBFIU
     247         [ +  + ]:     849081 :     fiu_return_on("fko_set_spa_digest_encoded", FKO_ERROR_MISSING_ENCODED_DATA);
     248                 :            : #endif
     249                 :            : 
     250                 :     849080 :     return set_digest(ctx->encoded_msg, &ctx->digest,
     251                 :     849080 :         ctx->digest_type, &ctx->digest_len);
     252                 :            : }
     253                 :            : 
     254                 :            : int
     255                 :      17696 : fko_set_raw_spa_digest(fko_ctx_t ctx)
     256                 :            : {
     257                 :            : #if HAVE_LIBFIU
     258         [ +  + ]:      17696 :     fiu_return_on("fko_set_raw_spa_digest_init", FKO_ERROR_CTX_NOT_INITIALIZED);
     259                 :            : #endif
     260                 :            :     /* Must be initialized
     261                 :            :     */
     262 [ +  + ][ +  - ]:      17695 :     if(!CTX_INITIALIZED(ctx))
     263                 :            :         return(FKO_ERROR_CTX_NOT_INITIALIZED);
     264                 :            : 
     265                 :            :     /* Must have encoded message data to start with.
     266                 :            :     */
     267         [ +  + ]:      17267 :     if(ctx->encrypted_msg == NULL)
     268                 :            :         return(FKO_ERROR_MISSING_ENCODED_DATA);
     269                 :            : 
     270                 :            : #if HAVE_LIBFIU
     271         [ +  - ]:      15999 :     fiu_return_on("fko_set_raw_spa_digest_val", FKO_ERROR_MISSING_ENCODED_DATA);
     272                 :            : #endif
     273                 :            : 
     274                 :      15999 :     return set_digest(ctx->encrypted_msg, &ctx->raw_digest,
     275                 :      15999 :         ctx->raw_digest_type, &ctx->raw_digest_len);
     276                 :            : }
     277                 :            : 
     278                 :            : int
     279                 :       3931 : fko_get_spa_digest(fko_ctx_t ctx, char **md)
     280                 :            : {
     281                 :            : #if HAVE_LIBFIU
     282         [ +  + ]:       3931 :     fiu_return_on("fko_get_spa_digest_init", FKO_ERROR_CTX_NOT_INITIALIZED);
     283                 :            : #endif
     284                 :            :     /* Must be initialized
     285                 :            :     */
     286 [ +  + ][ +  - ]:       3930 :     if(!CTX_INITIALIZED(ctx))
     287                 :            :         return(FKO_ERROR_CTX_NOT_INITIALIZED);
     288                 :            : 
     289                 :            : #if HAVE_LIBFIU
     290         [ +  + ]:       3778 :     fiu_return_on("fko_get_spa_digest_val", FKO_ERROR_INVALID_DATA);
     291                 :            : #endif
     292         [ +  + ]:       3777 :     if(md == NULL)
     293                 :            :         return(FKO_ERROR_INVALID_DATA);
     294                 :            : 
     295                 :       3709 :     *md = ctx->digest;
     296                 :            : 
     297                 :       3709 :     return(FKO_SUCCESS);
     298                 :            : }
     299                 :            : 
     300                 :            : int
     301                 :      15951 : fko_get_raw_spa_digest(fko_ctx_t ctx, char **md)
     302                 :            : {
     303                 :            : #if HAVE_LIBFIU
     304         [ +  + ]:      15951 :     fiu_return_on("fko_get_raw_spa_digest_init", FKO_ERROR_CTX_NOT_INITIALIZED);
     305                 :            : #endif
     306                 :            :     /* Must be initialized
     307                 :            :     */
     308 [ +  - ][ +  - ]:      15950 :     if(!CTX_INITIALIZED(ctx))
     309                 :            :         return(FKO_ERROR_CTX_NOT_INITIALIZED);
     310                 :            : 
     311                 :      15950 :     *md = ctx->raw_digest;
     312                 :            : 
     313                 :      15950 :     return(FKO_SUCCESS);
     314                 :            : }
     315                 :            : 
     316                 :            : /***EOF***/

Generated by: LCOV version 1.10