src/core/sipe-digest-nss.c

   1 /**
   2  * @file sipe-digest-nss.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2011-2016 SIPE Project <http://sipe.sourceforge.net/>
   7  * Copyright (C) 2010 pier11 <pier11@operamail.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 /**
  25  * Digest routines implementation based on NSS.
  26  * Includes: SHA1, MD5, HMAC_SHA_1, HMAC_MD5
  27  */
  28 #ifdef HAVE_CONFIG_H
  29 #include "config.h"
  30 #endif
  31
  32 #include "glib.h"
  33
  34 #include "nss.h"
  35 /*
  36  * Work around a compiler error in NSS 3.13.x. Let's hope they fix it for
  37  * 3.14.x. See also: https://bugzilla.mozilla.org/show_bug.cgi?id=702090
  38  */
  39 #if (NSS_VMAJOR == 3) && (NSS_VMINOR == 13)
  40 #define __GNUC_MINOR __GNUC_MINOR__
  41 #endif
  42 #include "pk11pub.h"
  43
  44 #include "sipe-digest.h"
  45 #if !(defined(HAVE_GSSAPI_ONLY) || defined(HAVE_SSPI))
  46 #include "md4.h"
  47 #endif
  48
  49
  50 /* PRIVATE methods */
  51
  52 static PK11Context *sipe_digest_ctx_create(const SECOidTag algorithm)
  53 {
  54         PK11Context *context = PK11_CreateDigestContext(algorithm);
  55         PK11_DigestBegin(context);
  56         return(context);
  57 }
  58
  59 static PK11Context*
  60 sipe_digest_hmac_ctx_create(CK_MECHANISM_TYPE hmacMech, const guchar *key, gsize key_length)
  61 {
  62         PK11SlotInfo* slot;
  63         SECItem keyItem;
  64         SECItem noParams;
  65         PK11SymKey* SymKey;
  66         PK11Context* DigestContext;
  67
  68         /* For key */
  69         slot = PK11_GetBestSlot(hmacMech, NULL);
  70
  71         keyItem.type = siBuffer;
  72         keyItem.data = (unsigned char *)key;
  73         keyItem.len = key_length;
  74
  75         SymKey = PK11_ImportSymKey(slot, hmacMech, PK11_OriginUnwrap, CKA_SIGN,  &keyItem, NULL);
  76
  77         /* Parameter for crypto context */
  78         noParams.type = siBuffer;
  79         noParams.data = NULL;
  80         noParams.len = 0;
  81
  82         DigestContext = PK11_CreateContextBySymKey(hmacMech, CKA_SIGN, SymKey, &noParams);
  83
  84         PK11_DigestBegin(DigestContext);
  85
  86         PK11_FreeSymKey(SymKey);
  87         PK11_FreeSlot(slot);
  88
  89         return DigestContext;
  90 }
  91
  92 static void sipe_digest_ctx_append(PK11Context* DigestContext, const guchar *data, gsize data_length)
  93 {
  94         PK11_DigestOp(DigestContext, data, data_length);
  95 }
  96
  97 static void sipe_digest_ctx_digest(PK11Context* DigestContext, guchar *digest, gsize digest_length)
  98 {
  99         unsigned int len;
 100
 101         PK11_DigestFinal(DigestContext, digest, &len, digest_length);
 102 }
 103
 104 static void sipe_digest_ctx_destroy(PK11Context* DigestContext)
 105 {
 106         PK11_DestroyContext(DigestContext, PR_TRUE);
 107 }
 108
 109 static void sipe_digest(const SECOidTag algorithm,
 110                         const guchar *data, gsize data_length,
 111                         guchar *digest, gsize digest_length)
 112 {
 113         void *DigestContext;
 114
 115         DigestContext = sipe_digest_ctx_create(algorithm);
 116         sipe_digest_ctx_append(DigestContext, data, data_length);
 117         sipe_digest_ctx_digest(DigestContext, digest, digest_length);
 118         sipe_digest_ctx_destroy(DigestContext);
 119 }
 120
 121 static void sipe_digest_hmac(CK_MECHANISM_TYPE hmacMech,
 122                              const guchar *key, gsize key_length,
 123                              const guchar *data, gsize data_length,
 124                              guchar *digest, gsize digest_length)
 125 {
 126         void *DigestContext;
 127
 128         DigestContext = sipe_digest_hmac_ctx_create(hmacMech, key, key_length);
 129         sipe_digest_ctx_append(DigestContext, data, data_length);
 130         sipe_digest_ctx_digest(DigestContext, digest, digest_length);
 131         sipe_digest_ctx_destroy(DigestContext);
 132 }
 133
 134
 135 /* PUBLIC methods */
 136
 137 #if !(defined(HAVE_GSSAPI_ONLY) || defined(HAVE_SSPI))
 138 /* One-shot MD4 digest - only used by internal NTLMv2 implementation */
 139 void sipe_digest_md4(const guchar *data, gsize length, guchar *digest)
 140 {
 141         /* NSS does not provide MD4 - use Mozilla Firefox implementation */
 142         md4sum(data, length, digest);
 143 }
 144 #endif
 145
 146 void sipe_digest_md5(const guchar *data, gsize length, guchar *digest)
 147 {
 148         sipe_digest(SEC_OID_MD5, data, length, digest, SIPE_DIGEST_MD5_LENGTH);
 149 }
 150
 151 void sipe_digest_sha1(const guchar *data, gsize length, guchar *digest)
 152 {
 153         sipe_digest(SEC_OID_SHA1, data, length, digest, SIPE_DIGEST_SHA1_LENGTH);
 154 }
 155
 156 void sipe_digest_hmac_md5(const guchar *key, gsize key_length,
 157                           const guchar *data, gsize data_length,
 158                           guchar *digest)
 159 {
 160         sipe_digest_hmac(CKM_MD5_HMAC, key, key_length, data, data_length, digest, SIPE_DIGEST_HMAC_MD5_LENGTH);
 161 }
 162
 163 void sipe_digest_hmac_sha1(const guchar *key, gsize key_length,
 164                            const guchar *data, gsize data_length,
 165                            guchar *digest)
 166 {
 167         sipe_digest_hmac(CKM_SHA_1_HMAC, key, key_length, data, data_length, digest, SIPE_DIGEST_HMAC_SHA1_LENGTH);
 168 }
 169
 170 /* Stream HMAC(SHA1) digest for file transfer */
 171 gpointer sipe_digest_ft_start(const guchar *sha1_digest)
 172 {
 173         /* used only the first 16 bytes of the 20 byte SHA1 digest */
 174         return sipe_digest_hmac_ctx_create(CKM_SHA_1_HMAC, sha1_digest, 16);
 175 }
 176
 177 void sipe_digest_ft_update(gpointer context, const guchar *data, gsize length)
 178 {
 179         sipe_digest_ctx_append(context, data, length);
 180 }
 181
 182 void sipe_digest_ft_end(gpointer context, guchar *digest)
 183 {
 184         sipe_digest_ctx_digest(context, digest, SIPE_DIGEST_FILETRANSFER_LENGTH);
 185 }
 186
 187 void sipe_digest_ft_destroy(gpointer context)
 188 {
 189         sipe_digest_ctx_destroy(context);
 190 }
 191
 192 /* Stream digests, e.g. for TLS */
 193 gpointer sipe_digest_md5_start(void)
 194 {
 195         return sipe_digest_ctx_create(SEC_OID_MD5);
 196 }
 197
 198 void sipe_digest_md5_update(gpointer context, const guchar *data, gsize length)
 199 {
 200         sipe_digest_ctx_append(context, data, length);
 201 }
 202
 203 void sipe_digest_md5_end(gpointer context, guchar *digest)
 204 {
 205         unsigned int saved_length;
 206         /* save context to ensure this function can be called multiple times */
 207         guchar *saved = PK11_SaveContextAlloc(context,
 208                                               NULL,
 209                                               0,
 210                                               &saved_length);
 211         sipe_digest_ctx_digest(context, digest, SIPE_DIGEST_MD5_LENGTH);
 212         PK11_RestoreContext(context, saved, saved_length);
 213         PORT_Free(saved);
 214 }
 215
 216 void sipe_digest_md5_destroy(gpointer context)
 217 {
 218         sipe_digest_ctx_destroy(context);
 219 }
 220
 221 gpointer sipe_digest_sha1_start(void)
 222 {
 223         return sipe_digest_ctx_create(SEC_OID_SHA1);
 224 }
 225
 226 void sipe_digest_sha1_update(gpointer context, const guchar *data, gsize length)
 227 {
 228         sipe_digest_ctx_append(context, data, length);
 229 }
 230
 231 void sipe_digest_sha1_end(gpointer context, guchar *digest)
 232 {
 233         unsigned int saved_length;
 234         /* save context to ensure this function can be called multiple times */
 235         guchar *saved = PK11_SaveContextAlloc(context,
 236                                               NULL,
 237                                               0,
 238                                               &saved_length);
 239         sipe_digest_ctx_digest(context, digest, SIPE_DIGEST_SHA1_LENGTH);
 240         PK11_RestoreContext(context, saved, saved_length);
 241         PORT_Free(saved);
 242 }
 243
 244 void sipe_digest_sha1_destroy(gpointer context)
 245 {
 246         sipe_digest_ctx_destroy(context);
 247 }
 248
 249 /*
 250   Local Variables:
 251   mode: c
 252   c-file-style: "bsd"
 253   indent-tabs-mode: t
 254   tab-width: 8
 255   End:
 256 */