lib/fko_digest.c

   1 /*
   2  *****************************************************************************
   3  *
   4  * File:    fko_digest.c
   5  *
   6  * Author:  Damien S. Stuart
   7  *
   8  * Purpose: Create the base64-encoded digest for the current spa data. The
   9  *          digest used is determined by the digest_type setting in the
  10  *          fko context.
  11  *
  12  * Copyright 2009-2010 Damien Stuart (dstuart@dstuart.org)
  13  *
  14  *  License (GNU Public License):
  15  *
  16  *  This program is free software; you can redistribute it and/or
  17  *  modify it under the terms of the GNU General Public License
  18  *  as published by the Free Software Foundation; either version 2
  19  *  of the License, or (at your option) any later version.
  20  *
  21  *  This program is distributed in the hope that it will be useful,
  22  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  *  GNU General Public License for more details.
  25  *
  26  *  You should have received a copy of the GNU General Public License
  27  *  along with this program; if not, write to the Free Software
  28  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  29  *  USA
  30  *
  31  *****************************************************************************
  32 */
  33 #include "fko_common.h"
  34 #include "fko.h"
  35 #include "digest.h"
  36
  37 /* Set the SPA digest type.
  38 */
  39 int
  40 fko_set_spa_digest_type(fko_ctx_t ctx, const short digest_type)
  41 {
  42     /* Must be initialized
  43     */
  44     if(!CTX_INITIALIZED(ctx))
  45         return(FKO_ERROR_CTX_NOT_INITIALIZED);
  46
  47     if(digest_type < 1 || digest_type >= FKO_LAST_DIGEST_TYPE)
  48         return(FKO_ERROR_INVALID_DATA);
  49
  50     ctx->digest_type = digest_type;
  51
  52     ctx->state |= FKO_DIGEST_TYPE_MODIFIED;
  53
  54     return(FKO_SUCCESS);
  55 }
  56
  57 /* Return the SPA digest type.
  58 */
  59 int
  60 fko_get_spa_digest_type(fko_ctx_t ctx, short *digest_type)
  61 {
  62     /* Must be initialized
  63     */
  64     if(!CTX_INITIALIZED(ctx))
  65         return(FKO_ERROR_CTX_NOT_INITIALIZED);
  66
  67     *digest_type = ctx->digest_type;
  68
  69     return(FKO_SUCCESS);
  70 }
  71
  72 int
  73 fko_set_spa_digest(fko_ctx_t ctx)
  74 {
  75     char    *md = NULL;
  76
  77     /* Must be initialized
  78     */
  79     if(!CTX_INITIALIZED(ctx))
  80         return(FKO_ERROR_CTX_NOT_INITIALIZED);
  81
  82     /* Must have encoded message data to start with.
  83     */
  84     if(ctx->encoded_msg == NULL)
  85         return(FKO_ERROR_MISSING_ENCODED_DATA);
  86
  87     switch(ctx->digest_type)
  88     {
  89         case FKO_DIGEST_MD5:
  90             md = malloc(MD_HEX_SIZE(MD5_DIGEST_LENGTH)+1);
  91             if(md == NULL)
  92                 return(FKO_ERROR_MEMORY_ALLOCATION);
  93
  94             md5_base64(md,
  95                 (unsigned char*)ctx->encoded_msg, strlen(ctx->encoded_msg));
  96             break;
  97
  98         case FKO_DIGEST_SHA1:
  99             md = malloc(MD_HEX_SIZE(SHA1_DIGEST_LENGTH)+1);
 100             if(md == NULL)
 101                 return(FKO_ERROR_MEMORY_ALLOCATION);
 102
 103             sha1_base64(md,
 104                 (unsigned char*)ctx->encoded_msg, strlen(ctx->encoded_msg));
 105             break;
 106
 107         case FKO_DIGEST_SHA256:
 108             md = malloc(MD_HEX_SIZE(SHA256_DIGEST_LENGTH)+1);
 109             if(md == NULL)
 110                 return(FKO_ERROR_MEMORY_ALLOCATION);
 111
 112             sha256_base64(md,
 113                 (unsigned char*)ctx->encoded_msg, strlen(ctx->encoded_msg));
 114             break;
 115
 116         case FKO_DIGEST_SHA384:
 117             md = malloc(MD_HEX_SIZE(SHA384_DIGEST_LENGTH)+1);
 118             if(md == NULL)
 119                 return(FKO_ERROR_MEMORY_ALLOCATION);
 120
 121             sha384_base64(md,
 122                 (unsigned char*)ctx->encoded_msg, strlen(ctx->encoded_msg));
 123             break;
 124
 125         case FKO_DIGEST_SHA512:
 126             md = malloc(MD_HEX_SIZE(SHA512_DIGEST_LENGTH)+1);
 127             if(md == NULL)
 128                 return(FKO_ERROR_MEMORY_ALLOCATION);
 129
 130             sha512_base64(md,
 131                 (unsigned char*)ctx->encoded_msg, strlen(ctx->encoded_msg));
 132             break;
 133
 134         default:
 135             return(FKO_ERROR_INVALID_DIGEST_TYPE);
 136     }
 137
 138     /* Just in case this is a subsquent call to this function.  We
 139      * do not want to be leaking memory.
 140     */
 141     if(ctx->digest != NULL)
 142         free(ctx->digest);
 143
 144     ctx->digest = md;
 145
 146     return(FKO_SUCCESS);
 147 }
 148
 149 int
 150 fko_get_spa_digest(fko_ctx_t ctx, char **md)
 151 {
 152     /* Must be initialized
 153     */
 154     if(!CTX_INITIALIZED(ctx))
 155         return(FKO_ERROR_CTX_NOT_INITIALIZED);
 156
 157     *md = ctx->digest;
 158
 159     return(FKO_SUCCESS);
 160 }
 161
 162 /***EOF***/