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
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
cipher_test_pbkdf2(void)
{
PurpleCipher *cipher;
PurpleHash *hash;
int i = 0;
gboolean fail = FALSE;
purple_debug_info("cipher-test", "Running PBKDF2 tests\n");
while (!fail && pbkdf2_tests[i].answer) {
pbkdf2_test *test = &pbkdf2_tests[i];
gchar digest[2 * 32 + 1 + 10];
gchar *digest_nss = NULL;
gboolean ret, skip_nss = FALSE;
i++;
purple_debug_info("cipher-test", "Test %02d:\n", i);
purple_debug_info("cipher-test",
"\tTesting '%s' with salt:'%s' hash:%s iter_count:%d \n",
test->passphrase, test->salt, test->hash,
test->iter_count);
if (!strcmp(test->hash, "sha1"))
hash = purple_sha1_hash_new();
else if (!strcmp(test->hash, "sha256"))
hash = purple_sha256_hash_new();
else
hash = NULL;
cipher = purple_pbkdf2_cipher_new(hash);
g_object_set(G_OBJECT(cipher), "iter_count", GUINT_TO_POINTER(test->iter_count), NULL);
g_object_set(G_OBJECT(cipher), "out_len", GUINT_TO_POINTER(test->out_len), NULL);
purple_cipher_set_salt(cipher, (const guchar*)test->salt, test->salt ? strlen(test->salt): 0);
purple_cipher_set_key(cipher, (const guchar*)test->passphrase, strlen(test->passphrase));
ret = purple_cipher_digest_to_str(cipher, digest, sizeof(digest));
purple_cipher_reset(cipher);
if (!ret) {
purple_debug_info("cipher-test", "\tfailed\n");
fail = TRUE;
g_object_unref(cipher);
g_object_unref(hash);
continue;
}
if (g_strcmp0(test->hash, "sha1") != 0)
skip_nss = TRUE;
if (test->out_len != 16 && test->out_len != 32)
skip_nss = TRUE;
#ifdef HAVE_NSS
if (!skip_nss) {
digest_nss = cipher_pbkdf2_nss_sha1(test->passphrase,
test->salt, test->iter_count, test->out_len);
}
#else
skip_nss = TRUE;
#endif
purple_debug_info("cipher-test", "\tGot: %s\n", digest);
if (digest_nss)
purple_debug_info("cipher-test", "\tGot from NSS: %s\n", digest_nss);
purple_debug_info("cipher-test", "\tWanted: %s\n", test->answer);
if (g_strcmp0(digest, test->answer) == 0 &&
(skip_nss || g_strcmp0(digest, digest_nss) == 0)) {
purple_debug_info("cipher-test", "\tTest OK\n");
}
else {
purple_debug_info("cipher-test", "\twrong answer\n");
fail = TRUE;
}
g_object_unref(cipher);
g_object_unref(hash);
}
if (fail)
purple_debug_info("cipher-test", "PBKDF2 tests FAILED\n\n");
else
purple_debug_info("cipher-test", "PBKDF2 tests completed successfully\n\n");
}
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;
}
