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;
}
