SecurityTests/cspxutils/ccOpensslCompat/digestCommon.h

   1 /*
   2  * digestCommon.h - openssl-style digest ops that can be redirected to CommonDigest.h
   3  */
   4
   5 /*
   6  * Currently, SHA2 functions are not implemented by OpenSSL, even though they are
   7  * present in the header <openssl/fips_sha.h>.
   8  *
   9  * <rdar://problem/4753005> SHA2 functions are declared, but not implemented
  10  *
  11  * For now we'll have to redirect openssl SHA2 calls manually just to get this
  12  * program to build and run correctly. (We could just disable all of the SHA2
  13  * code but we still get a benefit from compiling openssl-style code).
  14  */
  15 #define OPENSSL_SHA2_IMPLEMENTED        0
  16
  17 #include "digestCommonExtern.h"
  18
  19 #ifdef  COMMON_DIGEST_FOR_OPENSSL
  20
  21 /* redirecting to CommonDigest */
  22
  23 #define doMD2           md2cc
  24 #define doMD4           md4cc
  25 #define doMD5           md5cc
  26 #define doSHA1          sha1cc
  27 #define doSHA224        sha224cc
  28 #define doSHA256        sha256cc
  29 #define doSHA384        sha384cc
  30 #define doSHA512        sha512cc
  31
  32 #else   /* !COMMON_DIGEST_FOR_OPENSSL */
  33
  34 /* openssl */
  35
  36 #define doMD2           md2os
  37 #define doMD4           md4os
  38 #define doMD5           md5os
  39 #define doSHA1          sha1os
  40 #define doSHA224        sha224os
  41 #define doSHA256        sha256os
  42 #define doSHA384        sha384os
  43 #define doSHA512        sha512os
  44
  45 #if             !OPENSSL_SHA2_IMPLEMENTED
  46
  47 /* Hack: redirect SHA2 calls after all */
  48
  49 #include <CommonCrypto/CommonDigest.h>
  50
  51 #define SHA256_CTX                                      CC_SHA256_CTX
  52 #define SHA224_Init(c)                          CC_SHA224_Init(c)
  53 #define SHA224_Update(c,d,l)            CC_SHA224_Update(c,d,l)
  54 #define SHA224_Final(m, c)                      CC_SHA224_Final(m,c)
  55
  56 #define SHA256_Init(c)                          CC_SHA256_Init(c)
  57 #define SHA256_Update(c,d,l)            CC_SHA256_Update(c,d,l)
  58 #define SHA256_Final(m, c)                      CC_SHA256_Final(m,c)
  59
  60 #define SHA512_CTX                                      CC_SHA512_CTX
  61 #define SHA384_Init(c)                          CC_SHA384_Init(c)
  62 #define SHA384_Update(c,d,l)            CC_SHA384_Update(c,d,l)
  63 #define SHA384_Final(m, c)                      CC_SHA384_Final(m,c)
  64
  65 #define SHA512_Init(c)                          CC_SHA512_Init(c)
  66 #define SHA512_Update(c,d,l)            CC_SHA512_Update(c,d,l)
  67 #define SHA512_Final(m, c)                      CC_SHA512_Final(m,c)
  68
  69 #endif  /* OPENSSL_SHA2_IMPLEMENTED */
  70
  71
  72 #endif  /* COMMON_DIGEST_FOR_OPENSSL */
  73
  74 /* all functions return nonzero on error */
  75
  76 int doMD2(const void *p, unsigned long len, unsigned char *md)
  77 {
  78         /* OPenSSL MD2 is not orthogonal: the pointer is a const unsigned char * */
  79         MD2_CTX ctx;
  80         const unsigned char *cp = (const unsigned char *)p;
  81
  82         if(!MD2_Init(&ctx)) {
  83                 return -1;
  84         }
  85         if(!MD2_Update(&ctx, cp, len)) {
  86                 return -1;
  87         }
  88         if(!MD2_Final(md, &ctx)) {
  89                 return -1;
  90         }
  91         return 0;
  92 }
  93
  94 int doMD4(const void *p, unsigned long len, unsigned char *md)
  95 {
  96         MD4_CTX ctx;
  97         if(!MD4_Init(&ctx)) {
  98                 return -1;
  99         }
 100         if(!MD4_Update(&ctx, p, len)) {
 101                 return -1;
 102         }
 103         if(!MD4_Final(md, &ctx)) {
 104                 return -1;
 105         }
 106         return 0;
 107 }
 108
 109 int doMD5(const void *p, unsigned long len, unsigned char *md)
 110 {
 111         MD5_CTX ctx;
 112         if(!MD5_Init(&ctx)) {
 113                 return -1;
 114         }
 115         if(!MD5_Update(&ctx, p, len)) {
 116                 return -1;
 117         }
 118         if(!MD5_Final(md, &ctx)) {
 119                 return -1;
 120         }
 121         return 0;
 122 }
 123
 124 int doSHA1(const void *p, unsigned long len, unsigned char *md)
 125 {
 126         SHA_CTX ctx;
 127         if(!SHA1_Init(&ctx)) {
 128                 return -1;
 129         }
 130         if(!SHA1_Update(&ctx, p, len)) {
 131                 return -1;
 132         }
 133         if(!SHA1_Final(md, &ctx)) {
 134                 return -1;
 135         }
 136         return 0;
 137 }
 138
 139 int doSHA224(const void *p, unsigned long len, unsigned char *md)
 140 {
 141         SHA256_CTX ctx;
 142         if(!SHA224_Init(&ctx)) {
 143                 return -1;
 144         }
 145         if(!SHA224_Update(&ctx, p, len)) {
 146                 return -1;
 147         }
 148         if(!SHA224_Final(md, &ctx)) {
 149                 return -1;
 150         }
 151         return 0;
 152 }
 153
 154 int doSHA256(const void *p, unsigned long len, unsigned char *md)
 155 {
 156         SHA256_CTX ctx;
 157         if(!SHA256_Init(&ctx)) {
 158                 return -1;
 159         }
 160         if(!SHA256_Update(&ctx, p, len)) {
 161                 return -1;
 162         }
 163         if(!SHA256_Final(md, &ctx)) {
 164                 return -1;
 165         }
 166         return 0;
 167 }
 168
 169 int doSHA384(const void *p, unsigned long len, unsigned char *md)
 170 {
 171         SHA512_CTX ctx;
 172         if(!SHA384_Init(&ctx)) {
 173                 return -1;
 174         }
 175         if(!SHA384_Update(&ctx, p, len)) {
 176                 return -1;
 177         }
 178         if(!SHA384_Final(md, &ctx)) {
 179                 return -1;
 180         }
 181         return 0;
 182 }
 183
 184 int doSHA512(const void *p, unsigned long len, unsigned char *md)
 185 {
 186         SHA512_CTX ctx;
 187         if(!SHA512_Init(&ctx)) {
 188                 return -1;
 189         }
 190         if(!SHA512_Update(&ctx, p, len)) {
 191                 return -1;
 192         }
 193         if(!SHA512_Final(md, &ctx)) {
 194                 return -1;
 195         }
 196         return 0;
 197 }