src/core/sipe-digest-nss.c

   1 /**
   2  * @file sipe-digest-nss.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2011 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
  29 #include "glib.h"
  30
  31 #include "nss.h"
  32 /*
  33  * Work around a compiler error in NSS 3.13.x. Let's hope they fix it for
  34  * 3.14.x. See also: https://bugzilla.mozilla.org/show_bug.cgi?id=702090
  35  */
  36 #if (NSS_VMAJOR == 3) && (NSS_VMINOR == 13)
  37 #define __GNUC_MINOR __GNUC_MINOR__
  38 #endif
  39 #include "pk11pub.h"
  40
  41 #include "sipe-digest.h"
  42
  43
  44 /* PRIVATE methods */
  45
  46 static PK11Context *sipe_digest_ctx_create(const SECOidTag algorithm)
  47 {
  48         PK11Context *context = PK11_CreateDigestContext(algorithm);
  49         PK11_DigestBegin(context);
  50         return(context);
  51 }
  52
  53 static PK11Context*
  54 sipe_digest_hmac_ctx_create(CK_MECHANISM_TYPE hmacMech, const guchar *key, gsize key_length)
  55 {
  56         PK11SlotInfo* slot;
  57         SECItem keyItem;
  58         SECItem noParams;
  59         PK11SymKey* SymKey;
  60         PK11Context* DigestContext;
  61
  62         /* For key */
  63         slot = PK11_GetBestSlot(hmacMech, NULL);
  64
  65         keyItem.type = siBuffer;
  66         keyItem.data = (unsigned char *)key;
  67         keyItem.len = key_length;
  68
  69         SymKey = PK11_ImportSymKey(slot, hmacMech, PK11_OriginUnwrap, CKA_SIGN,  &keyItem, NULL);
  70
  71         /* Parameter for crypto context */
  72         noParams.type = siBuffer;
  73         noParams.data = NULL;
  74         noParams.len = 0;
  75
  76         DigestContext = PK11_CreateContextBySymKey(hmacMech, CKA_SIGN, SymKey, &noParams);
  77
  78         PK11_DigestBegin(DigestContext);
  79
  80         PK11_FreeSymKey(SymKey);
  81         PK11_FreeSlot(slot);
  82
  83         return DigestContext;
  84 }
  85
  86 static void sipe_digest_ctx_append(PK11Context* DigestContext, const guchar *data, gsize data_length)
  87 {
  88         PK11_DigestOp(DigestContext, data, data_length);
  89 }
  90
  91 static void sipe_digest_ctx_digest(PK11Context* DigestContext, guchar *digest, gsize digest_length)
  92 {
  93         unsigned int len;
  94
  95         PK11_DigestFinal(DigestContext, digest, &len, digest_length);
  96 }
  97
  98 static void sipe_digest_ctx_destroy(PK11Context* DigestContext)
  99 {
 100         PK11_DestroyContext(DigestContext, PR_TRUE);
 101 }
 102
 103 static void sipe_digest(const SECOidTag algorithm,
 104                         const guchar *data, gsize data_length,
 105                         guchar *digest, gsize digest_length)
 106 {
 107         void *DigestContext;
 108
 109         DigestContext = sipe_digest_ctx_create(algorithm);
 110         sipe_digest_ctx_append(DigestContext, data, data_length);
 111         sipe_digest_ctx_digest(DigestContext, digest, digest_length);
 112         sipe_digest_ctx_destroy(DigestContext);
 113 }
 114
 115 static void sipe_digest_hmac(CK_MECHANISM_TYPE hmacMech,
 116                              const guchar *key, gsize key_length,
 117                              const guchar *data, gsize data_length,
 118                              guchar *digest, gsize digest_length)
 119 {
 120         void *DigestContext;
 121
 122         DigestContext = sipe_digest_hmac_ctx_create(hmacMech, key, key_length);
 123         sipe_digest_ctx_append(DigestContext, data, data_length);
 124         sipe_digest_ctx_digest(DigestContext, digest, digest_length);
 125         sipe_digest_ctx_destroy(DigestContext);
 126 }
 127
 128
 129 /* PUBLIC methods */
 130
 131 void sipe_digest_md5(const guchar *data, gsize length, guchar *digest)
 132 {
 133         sipe_digest(SEC_OID_MD5, data, length, digest, SIPE_DIGEST_MD5_LENGTH);
 134 }
 135
 136 void sipe_digest_sha1(const guchar *data, gsize length, guchar *digest)
 137 {
 138         sipe_digest(SEC_OID_SHA1, data, length, digest, SIPE_DIGEST_SHA1_LENGTH);
 139 }
 140
 141 void sipe_digest_hmac_md5(const guchar *key, gsize key_length,
 142                           const guchar *data, gsize data_length,
 143                           guchar *digest)
 144 {
 145         sipe_digest_hmac(CKM_MD5_HMAC, key, key_length, data, data_length, digest, SIPE_DIGEST_HMAC_MD5_LENGTH);
 146 }
 147
 148 void sipe_digest_hmac_sha1(const guchar *key, gsize key_length,
 149                            const guchar *data, gsize data_length,
 150                            guchar *digest)
 151 {
 152         sipe_digest_hmac(CKM_SHA_1_HMAC, key, key_length, data, data_length, digest, SIPE_DIGEST_HMAC_SHA1_LENGTH);
 153 }
 154
 155 /* Stream HMAC(SHA1) digest for file transfer */
 156 gpointer sipe_digest_ft_start(const guchar *sha1_digest)
 157 {
 158         /* used only the first 16 bytes of the 20 byte SHA1 digest */
 159         return sipe_digest_hmac_ctx_create(CKM_SHA_1_HMAC, sha1_digest, 16);
 160 }
 161
 162 void sipe_digest_ft_update(gpointer context, const guchar *data, gsize length)
 163 {
 164         sipe_digest_ctx_append(context, data, length);
 165 }
 166
 167 void sipe_digest_ft_end(gpointer context, guchar *digest)
 168 {
 169         sipe_digest_ctx_digest(context, digest, SIPE_DIGEST_FILETRANSFER_LENGTH);
 170 }
 171
 172 void sipe_digest_ft_destroy(gpointer context)
 173 {
 174         sipe_digest_ctx_destroy(context);
 175 }
 176
 177 /* Stream digests, e.g. for TLS */
 178 gpointer sipe_digest_md5_start(void)
 179 {
 180         return sipe_digest_ctx_create(SEC_OID_MD5);
 181 }
 182
 183 void sipe_digest_md5_update(gpointer context, const guchar *data, gsize length)
 184 {
 185         sipe_digest_ctx_append(context, data, length);
 186 }
 187
 188 void sipe_digest_md5_end(gpointer context, guchar *digest)
 189 {
 190         unsigned int saved_length;
 191         /* save context to ensure this function can be called multiple times */
 192         guchar *saved = PK11_SaveContextAlloc(context,
 193                                               NULL,
 194                                               0,
 195                                               &saved_length);
 196         sipe_digest_ctx_digest(context, digest, SIPE_DIGEST_MD5_LENGTH);
 197         PK11_RestoreContext(context, saved, saved_length);
 198         PORT_Free(saved);
 199 }
 200
 201 void sipe_digest_md5_destroy(gpointer context)
 202 {
 203         sipe_digest_ctx_destroy(context);
 204 }
 205
 206 gpointer sipe_digest_sha1_start(void)
 207 {
 208         return sipe_digest_ctx_create(SEC_OID_SHA1);
 209 }
 210
 211 void sipe_digest_sha1_update(gpointer context, const guchar *data, gsize length)
 212 {
 213         sipe_digest_ctx_append(context, data, length);
 214 }
 215
 216 void sipe_digest_sha1_end(gpointer context, guchar *digest)
 217 {
 218         unsigned int saved_length;
 219         /* save context to ensure this function can be called multiple times */
 220         guchar *saved = PK11_SaveContextAlloc(context,
 221                                               NULL,
 222                                               0,
 223                                               &saved_length);
 224         sipe_digest_ctx_digest(context, digest, SIPE_DIGEST_SHA1_LENGTH);
 225         PK11_RestoreContext(context, saved, saved_length);
 226         PORT_Free(saved);
 227 }
 228
 229 void sipe_digest_sha1_destroy(gpointer context)
 230 {
 231         sipe_digest_ctx_destroy(context);
 232 }
 233
 234 /*
 235   Local Variables:
 236   mode: c
 237   c-file-style: "bsd"
 238   indent-tabs-mode: t
 239   tab-width: 8
 240   End:
 241 */