static void test_sha256hash(gchar *data, gchar *digest) { PurpleHash *hash = NULL; gchar cdigest[65]; gboolean ret = FALSE; hash = purple_sha256_hash_new(); if(data) { purple_hash_append(hash, (guchar *)data, strlen(data)); } else { gint j; guchar buff[1000]; memset(buff, 'a', 1000); for(j = 0; j < 1000; j++) purple_hash_append(hash, buff, 1000); } ret = purple_hash_digest_to_str(hash, cdigest, sizeof(cdigest)); g_assert(ret); g_assert_cmpstr(digest, ==, cdigest); }
static char * generate_response_value(JabberID *jid, const char *passwd, const char *nonce, const char *cnonce, const char *a2, const char *realm) { PurpleHash *hash; guchar result[16]; size_t a1len; gchar *a1, *convnode=NULL, *convpasswd = NULL, *ha1, *ha2, *kd, *x, *z; if((convnode = g_convert(jid->node, -1, "iso-8859-1", "utf-8", NULL, NULL, NULL)) == NULL) { convnode = g_strdup(jid->node); } if(passwd && ((convpasswd = g_convert(passwd, -1, "iso-8859-1", "utf-8", NULL, NULL, NULL)) == NULL)) { convpasswd = g_strdup(passwd); } hash = purple_md5_hash_new(); x = g_strdup_printf("%s:%s:%s", convnode, realm, convpasswd ? convpasswd : ""); purple_hash_append(hash, (const guchar *)x, strlen(x)); purple_hash_digest(hash, result, sizeof(result)); a1 = g_strdup_printf("xxxxxxxxxxxxxxxx:%s:%s", nonce, cnonce); a1len = strlen(a1); g_memmove(a1, result, 16); purple_hash_reset(hash); purple_hash_append(hash, (const guchar *)a1, a1len); purple_hash_digest(hash, result, sizeof(result)); ha1 = purple_base16_encode(result, 16); purple_hash_reset(hash); purple_hash_append(hash, (const guchar *)a2, strlen(a2)); purple_hash_digest(hash, result, sizeof(result)); ha2 = purple_base16_encode(result, 16); kd = g_strdup_printf("%s:%s:00000001:%s:auth:%s", ha1, nonce, cnonce, ha2); purple_hash_reset(hash); purple_hash_append(hash, (const guchar *)kd, strlen(kd)); purple_hash_digest(hash, result, sizeof(result)); g_object_unref(hash); z = purple_base16_encode(result, 16); g_free(convnode); g_free(convpasswd); g_free(x); g_free(a1); g_free(ha1); g_free(ha2); g_free(kd); return z; }
static void cipher_test_sha1(void) { PurpleHash *hash; gchar digest[41]; gint i = 0; gboolean ret; hash = purple_sha1_hash_new(); if(!hash) { purple_debug_info("cipher-test", "could not find sha1 cipher, not testing\n"); return; } purple_debug_info("cipher-test", "Running sha1 tests\n"); while(sha1_tests[i].answer) { purple_debug_info("cipher-test", "Test %02d:\n", i); purple_debug_info("cipher-test", "Testing '%s'\n", (sha1_tests[i].question != NULL) ? sha1_tests[i].question : "'a'x1000, 1000 times"); if(sha1_tests[i].question) { purple_hash_append(hash, (guchar *)sha1_tests[i].question, strlen(sha1_tests[i].question)); } else { gint j; guchar buff[1000]; memset(buff, 'a', 1000); for(j = 0; j < 1000; j++) purple_hash_append(hash, buff, 1000); } ret = purple_hash_digest_to_str(hash, digest, sizeof(digest)); if(!ret) { purple_debug_info("cipher-test", "failed\n"); } else { purple_debug_info("cipher-test", "\tGot: %s\n", digest); purple_debug_info("cipher-test", "\tWanted: %s\n", sha1_tests[i].answer); } purple_hash_reset(hash); i++; } g_object_unref(hash); purple_debug_info("cipher-test", "sha1 tests completed\n\n"); }
static void purple_hmac_cipher_append(PurpleCipher *cipher, const guchar *d, size_t l) { PurpleHMACCipherPrivate *priv = PURPLE_HMAC_CIPHER_GET_PRIVATE(cipher); g_return_if_fail(PURPLE_IS_HASH(priv->hash)); purple_hash_append(priv->hash, d, l); }
static void bonjour_bytestreams_connect(PurpleXfer *xfer) { PurpleBuddy *pb; PurpleAccount *account = NULL; PurpleHash *hash; XepXfer *xf; char dstaddr[41]; const gchar *name = NULL; unsigned char hashval[20]; char *p; int i; if(xfer == NULL) return; purple_debug_info("bonjour", "bonjour-bytestreams-connect.\n"); xf = purple_xfer_get_protocol_data(xfer); if(!xf) return; pb = xf->pb; name = purple_buddy_get_name(pb); account = purple_buddy_get_account(pb); p = g_strdup_printf("%s%s%s", xf->sid, name, bonjour_get_jid(account)); hash = purple_sha1_hash_new(); purple_hash_append(hash, (guchar *)p, strlen(p)); purple_hash_digest(hash, hashval, sizeof(hashval)); g_object_unref(G_OBJECT(hash)); g_free(p); memset(dstaddr, 0, 41); p = dstaddr; for(i = 0; i < 20; i++, p += 2) snprintf(p, 3, "%02x", hashval[i]); xf->proxy_info = purple_proxy_info_new(); purple_proxy_info_set_proxy_type(xf->proxy_info, PURPLE_PROXY_SOCKS5); purple_proxy_info_set_host(xf->proxy_info, xf->proxy_host); purple_proxy_info_set_port(xf->proxy_info, xf->proxy_port); xf->proxy_connection = purple_proxy_connect_socks5_account( purple_account_get_connection(account), account, xf->proxy_info, dstaddr, 0, bonjour_bytestreams_connect_cb, xfer); if(xf->proxy_connection == NULL) { xep_ft_si_reject(xf->data, xf->iq_id, purple_xfer_get_remote_user(xfer), "404", "cancel"); /* Cancel the connection */ purple_xfer_cancel_local(xfer); } }
static void hash(const JabberScramHash *hash, guchar *out, const guchar *data) { PurpleHash *hasher; hasher = hash->new_cipher(); purple_hash_append(hasher, data, hash->size); purple_hash_digest(hasher, out, hash->size); g_object_unref(G_OBJECT(hasher)); }
static void purple_hmac_cipher_reset_state(PurpleCipher *cipher) { PurpleHMACCipherPrivate *priv = PURPLE_HMAC_CIPHER_GET_PRIVATE(cipher); if(PURPLE_IS_HASH(priv->hash)) { purple_hash_reset_state(priv->hash); purple_hash_append(priv->hash, priv->ipad, purple_hash_get_block_size(priv->hash)); } }
static void purple_hmac_cipher_set_key(PurpleCipher *cipher, const guchar *key, size_t key_len) { PurpleHMACCipherPrivate *priv = PURPLE_HMAC_CIPHER_GET_PRIVATE(cipher); gsize block_size, i; guchar *full_key; g_return_if_fail(priv->hash); g_free(priv->ipad); g_free(priv->opad); block_size = purple_hash_get_block_size(priv->hash); priv->ipad = g_malloc(block_size); priv->opad = g_malloc(block_size); if (key_len > block_size) { purple_hash_reset(priv->hash); purple_hash_append(priv->hash, key, key_len); key_len = purple_hash_get_digest_size(priv->hash); full_key = g_malloc(key_len); purple_hash_digest(priv->hash, full_key, key_len); } else { full_key = g_memdup(key, key_len); } if (key_len < block_size) { full_key = g_realloc(full_key, block_size); memset(full_key + key_len, 0, block_size - key_len); } for(i = 0; i < block_size; i++) { priv->ipad[i] = 0x36 ^ full_key[i]; priv->opad[i] = 0x5c ^ full_key[i]; } g_free(full_key); purple_hash_reset(priv->hash); purple_hash_append(priv->hash, priv->ipad, block_size); }
static gboolean purple_hmac_cipher_digest(PurpleCipher *cipher, guchar *out, size_t len) { PurpleHMACCipherPrivate *priv = PURPLE_HMAC_CIPHER_GET_PRIVATE(cipher); guchar *digest = NULL; size_t hash_len, block_size; gboolean result = FALSE; g_return_val_if_fail(PURPLE_IS_HASH(priv->hash), FALSE); hash_len = purple_hash_get_digest_size(priv->hash); g_return_val_if_fail(hash_len > 0, FALSE); block_size = purple_hash_get_block_size(priv->hash); digest = g_malloc(hash_len); /* get the digest of the data */ result = purple_hash_digest(priv->hash, digest, hash_len); purple_hash_reset(priv->hash); if(!result) { g_free(digest); return FALSE; } /* now append the opad and the digest from above */ purple_hash_append(priv->hash, priv->opad, block_size); purple_hash_append(priv->hash, digest, hash_len); /* do our last digest */ result = purple_hash_digest(priv->hash, out, len); /* cleanup */ g_free(digest); return result; }
static void cipher_test_md5(void) { PurpleHash *hash; gchar digest[33]; gboolean ret; gint i = 0; hash = purple_md5_hash_new(); if(!hash) { purple_debug_info("cipher-test", "could not find md5 cipher, not testing\n"); return; } purple_debug_info("cipher-test", "Running md5 tests\n"); while(md5_tests[i].answer) { purple_debug_info("cipher-test", "Test %02d:\n", i); purple_debug_info("cipher-test", "Testing '%s'\n", md5_tests[i].question); purple_hash_append(hash, (guchar *)md5_tests[i].question, strlen(md5_tests[i].question)); ret = purple_hash_digest_to_str(hash, digest, sizeof(digest)); if(!ret) { purple_debug_info("cipher-test", "failed\n"); } else { purple_debug_info("cipher-test", "\tGot: %s\n", digest); purple_debug_info("cipher-test", "\tWanted: %s\n", md5_tests[i].answer); } purple_hash_reset(hash); i++; } g_object_unref(hash); purple_debug_info("cipher-test", "md5 tests completed\n\n"); }
void msn_handle_chl(char *input, char *output) { PurpleHash *hash; const guchar productKey[] = MSNP15_WLM_PRODUCT_KEY; const guchar productID[] = MSNP15_WLM_PRODUCT_ID; const char hexChars[] = "0123456789abcdef"; char buf[BUFSIZE]; guint32 md5Parts[4]; unsigned char *newHash; guint32 chlStringParts[BUFSIZE / sizeof(guint32)]; unsigned int newHashParts[5]; long long nHigh = 0, nLow = 0; int len; int i; /* Create the MD5 hash by using Purple MD5 algorithm */ hash = purple_md5_hash_new(); purple_hash_append(hash, (guchar *)input, strlen(input)); purple_hash_append(hash, productKey, sizeof(productKey) - 1); purple_hash_digest(hash, (guchar *)md5Parts, sizeof(md5Parts)); g_object_unref(hash); /* Split it into four integers */ for (i = 0; i < 4; i++) { /* adjust endianess */ md5Parts[i] = GUINT_TO_LE(md5Parts[i]); /* & each integer with 0x7FFFFFFF */ /* and save one unmodified array for later */ newHashParts[i] = md5Parts[i]; md5Parts[i] &= 0x7FFFFFFF; } /* make a new string and pad with '0' to length that's a multiple of 8 */ snprintf(buf, BUFSIZE - 5, "%s%s", input, productID); len = strlen(buf); if ((len % 8) != 0) { int fix = 8 - (len % 8); strncpy(&buf[len], "00000000", fix); buf[len + fix] = '\0'; len += fix; } /* split into integers */ memcpy(&chlStringParts, &buf, sizeof(chlStringParts)); /* this is magic */ for (i = 0; i < (len / 4); i += 2) { long long temp; chlStringParts[i] = GUINT_TO_LE(chlStringParts[i]); chlStringParts[i + 1] = GUINT_TO_LE(chlStringParts[i + 1]); temp = (0x0E79A9C1 * (long long)chlStringParts[i]) % 0x7FFFFFFF; temp = (md5Parts[0] * (temp + nLow) + md5Parts[1]) % 0x7FFFFFFF; nHigh += temp; temp = ((long long)chlStringParts[i + 1] + temp) % 0x7FFFFFFF; nLow = (md5Parts[2] * temp + md5Parts[3]) % 0x7FFFFFFF; nHigh += nLow; } nLow = (nLow + md5Parts[1]) % 0x7FFFFFFF; nHigh = (nHigh + md5Parts[3]) % 0x7FFFFFFF; newHashParts[0] ^= nLow; newHashParts[1] ^= nHigh; newHashParts[2] ^= nLow; newHashParts[3] ^= nHigh; /* adjust endianness */ for(i = 0; i < 4; i++) newHashParts[i] = GUINT_TO_LE(newHashParts[i]); /* make a string of the parts */ newHash = (unsigned char *)newHashParts; /* convert to hexadecimal */ for (i = 0; i < 16; i++) { output[i * 2] = hexChars[(newHash[i] >> 4) & 0xF]; output[(i * 2) + 1] = hexChars[newHash[i] & 0xF]; } output[32] = '\0'; }
char * skypeweb_hmac_sha256(char *input) { PurpleHash *hash; const guchar productKey[] = SKYPEWEB_LOCKANDKEY_SECRET; const guchar productID[] = SKYPEWEB_LOCKANDKEY_APPID; const char hexChars[] = "0123456789abcdef"; char buf[BUFSIZE]; unsigned char sha256Hash[32]; unsigned char *newHash; unsigned int *sha256Parts; unsigned int *chlStringParts; unsigned int newHashParts[5]; gchar *output; long long nHigh = 0, nLow = 0; int len; int i; hash = purple_sha256_hash_new(); purple_hash_append(hash, (guchar *)input, strlen(input)); purple_hash_append(hash, productKey, sizeof(productKey) - 1); purple_hash_digest(hash, (guchar *)sha256Hash, sizeof(sha256Hash)); purple_hash_destroy(hash); /* Split it into four integers */ sha256Parts = (unsigned int *)sha256Hash; for (i = 0; i < 4; i++) { /* adjust endianess */ sha256Parts[i] = GUINT_TO_LE(sha256Parts[i]); /* & each integer with 0x7FFFFFFF */ /* and save one unmodified array for later */ newHashParts[i] = sha256Parts[i]; sha256Parts[i] &= 0x7FFFFFFF; } /* make a new string and pad with '0' to length that's a multiple of 8 */ snprintf(buf, BUFSIZE - 5, "%s%s", input, productID); len = strlen(buf); if ((len % 8) != 0) { int fix = 8 - (len % 8); memset(&buf[len], '0', fix); buf[len + fix] = '\0'; len += fix; } /* split into integers */ chlStringParts = (unsigned int *)buf; /* this is magic */ for (i = 0; i < (len / 4); i += 2) { long long temp; chlStringParts[i] = GUINT_TO_LE(chlStringParts[i]); chlStringParts[i + 1] = GUINT_TO_LE(chlStringParts[i + 1]); temp = (0x0E79A9C1 * (long long)chlStringParts[i]) % 0x7FFFFFFF; temp = (sha256Parts[0] * (temp + nLow) + sha256Parts[1]) % 0x7FFFFFFF; nHigh += temp; temp = ((long long)chlStringParts[i + 1] + temp) % 0x7FFFFFFF; nLow = (sha256Parts[2] * temp + sha256Parts[3]) % 0x7FFFFFFF; nHigh += nLow; } nLow = (nLow + sha256Parts[1]) % 0x7FFFFFFF; nHigh = (nHigh + sha256Parts[3]) % 0x7FFFFFFF; newHashParts[0] ^= nLow; newHashParts[1] ^= nHigh; newHashParts[2] ^= nLow; newHashParts[3] ^= nHigh; /* adjust endianness */ for(i = 0; i < 4; i++) newHashParts[i] = GUINT_TO_LE(newHashParts[i]); /* make a string of the parts */ newHash = (unsigned char *)newHashParts; /* convert to hexadecimal */ output = g_new0(gchar, 33); for (i = 0; i < 16; i++) { output[i * 2] = hexChars[(newHash[i] >> 4) & 0xF]; output[(i * 2) + 1] = hexChars[newHash[i] & 0xF]; } output[32] = '\0'; return output; }
MsnObject* msn_object_new_from_image(PurpleStoredImage *img, const char *location, const char *creator, MsnObjectType type) { MsnObject *msnobj; PurpleHash *hash; char *buf; gconstpointer data; size_t size; char *base64; unsigned char digest[20]; msnobj = NULL; if (img == NULL) return msnobj; size = purple_imgstore_get_size(img); data = purple_imgstore_get_data(img); /* New object */ msnobj = msn_object_new(); msn_object_set_local(msnobj); msn_object_set_type(msnobj, type); msn_object_set_location(msnobj, location); msn_object_set_creator(msnobj, creator); msn_object_set_image(msnobj, img); /* Compute the SHA1D field. */ memset(digest, 0, sizeof(digest)); hash = purple_sha1_hash_new(); purple_hash_append(hash, data, size); purple_hash_digest(hash, digest, sizeof(digest)); base64 = purple_base64_encode(digest, sizeof(digest)); msn_object_set_sha1d(msnobj, base64); g_free(base64); msn_object_set_size(msnobj, size); /* Compute the SHA1C field. */ buf = g_strdup_printf( "Creator%sSize%dType%dLocation%sFriendly%sSHA1D%s", msn_object_get_creator(msnobj), msn_object_get_size(msnobj), msn_object_get_type(msnobj), msn_object_get_location(msnobj), msn_object_get_friendly(msnobj), msn_object_get_sha1d(msnobj)); memset(digest, 0, sizeof(digest)); purple_hash_reset(hash); purple_hash_append(hash, (const guchar *)buf, strlen(buf)); purple_hash_digest(hash, digest, sizeof(digest)); g_object_unref(hash); g_free(buf); base64 = purple_base64_encode(digest, sizeof(digest)); msn_object_set_sha1c(msnobj, base64); g_free(base64); return msnobj; }