void silc_client_current_channel_private_key(SilcClient client,
SilcClientConnection conn,
SilcChannelEntry channel,
SilcChannelPrivateKey key)
{
if (!channel)
return;
channel->internal.curr_key = key;
channel->cipher = silc_cipher_get_name(key->send_key);
channel->hmac = silc_hmac_get_name(key->hmac);
}
SilcBool silc_client_del_channel_private_key(SilcClient client,
SilcClientConnection conn,
SilcChannelEntry channel,
SilcChannelPrivateKey key)
{
SilcChannelPrivateKey entry;
if (!client || !conn || !channel)
return FALSE;
if (!channel->internal.private_keys)
return FALSE;
silc_dlist_start(channel->internal.private_keys);
while ((entry = silc_dlist_get(channel->internal.private_keys))) {
if (entry != key)
continue;
if (channel->internal.curr_key == entry) {
channel->internal.curr_key = NULL;
channel->cipher = silc_cipher_get_name(channel->internal.send_key);
channel->hmac = silc_hmac_get_name(channel->internal.hmac);
}
silc_dlist_del(channel->internal.private_keys, entry);
silc_free(entry->name);
silc_cipher_free(entry->send_key);
silc_cipher_free(entry->receive_key);
silc_hmac_free(entry->hmac);
silc_free(entry);
if (silc_dlist_count(channel->internal.private_keys) == 0) {
silc_dlist_uninit(channel->internal.private_keys);
channel->internal.private_keys = NULL;
}
return TRUE;
}
return FALSE;
}
static SilcBool
silc_client_send_private_message_key_request(SilcClient client,
SilcClientConnection conn,
SilcClientEntry client_entry)
{
const char *cipher, *hmac;
SILC_LOG_DEBUG(("Sending private message key request"));
cipher = silc_cipher_get_name(client_entry->internal.send_key);
hmac = silc_hmac_get_name(client_entry->internal.hmac_send);
/* Send the packet */
return silc_packet_send_va_ext(conn->stream,
SILC_PACKET_PRIVATE_MESSAGE_KEY,
0, 0, NULL, SILC_ID_CLIENT,
&client_entry->id, NULL, NULL,
SILC_STR_UI_SHORT(strlen(cipher)),
SILC_STR_DATA(cipher, strlen(cipher)),
SILC_STR_UI_SHORT(strlen(hmac)),
SILC_STR_DATA(hmac, strlen(hmac)),
SILC_STR_END);
}
static void
silcpurple_chat_getinfo(PurpleConnection *gc, GHashTable *components)
{
SilcPurple sg = gc->proto_data;
const char *chname;
char *buf, tmp[256], *tmp2;
GString *s;
SilcChannelEntry channel;
SilcHashTableList htl;
SilcChannelUser chu;
if (!components)
return;
chname = g_hash_table_lookup(components, "channel");
if (!chname)
return;
channel = silc_client_get_channel(sg->client, sg->conn,
(char *)chname);
if (!channel) {
silc_client_get_channel_resolve(sg->client, sg->conn,
(char *)chname,
silcpurple_chat_getinfo_res,
components);
return;
}
s = g_string_new("");
tmp2 = g_markup_escape_text(channel->channel_name, -1);
g_string_append_printf(s, _("<b>Channel Name:</b> %s"), tmp2);
g_free(tmp2);
if (channel->user_list && silc_hash_table_count(channel->user_list))
g_string_append_printf(s, _("<br><b>User Count:</b> %d"),
(int)silc_hash_table_count(channel->user_list));
silc_hash_table_list(channel->user_list, &htl);
while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {
if (chu->mode & SILC_CHANNEL_UMODE_CHANFO) {
tmp2 = g_markup_escape_text(chu->client->nickname, -1);
g_string_append_printf(s, _("<br><b>Channel Founder:</b> %s"),
tmp2);
g_free(tmp2);
break;
}
}
silc_hash_table_list_reset(&htl);
if (channel->channel_key)
g_string_append_printf(s, _("<br><b>Channel Cipher:</b> %s"),
silc_cipher_get_name(channel->channel_key));
if (channel->hmac)
/* Definition of HMAC: http://en.wikipedia.org/wiki/HMAC */
g_string_append_printf(s, _("<br><b>Channel HMAC:</b> %s"),
silc_hmac_get_name(channel->hmac));
if (channel->topic) {
tmp2 = g_markup_escape_text(channel->topic, -1);
g_string_append_printf(s, _("<br><b>Channel Topic:</b><br>%s"), tmp2);
g_free(tmp2);
}
if (channel->mode) {
g_string_append_printf(s, _("<br><b>Channel Modes:</b> "));
silcpurple_get_chmode_string(channel->mode, tmp, sizeof(tmp));
g_string_append(s, tmp);
}
if (channel->founder_key) {
char *fingerprint, *babbleprint;
unsigned char *pk;
SilcUInt32 pk_len;
pk = silc_pkcs_public_key_encode(channel->founder_key, &pk_len);
fingerprint = silc_hash_fingerprint(NULL, pk, pk_len);
babbleprint = silc_hash_babbleprint(NULL, pk, pk_len);
g_string_append_printf(s, _("<br><b>Founder Key Fingerprint:</b><br>%s"), fingerprint);
g_string_append_printf(s, _("<br><b>Founder Key Babbleprint:</b><br>%s"), babbleprint);
silc_free(fingerprint);
silc_free(babbleprint);
silc_free(pk);
}
buf = g_string_free(s, FALSE);
purple_notify_formatted(gc, NULL, _("Channel Information"), NULL, buf, NULL, NULL);
g_free(buf);
}
SilcBool silc_client_save_channel_key(SilcClient client,
SilcClientConnection conn,
SilcBuffer key_payload,
SilcChannelEntry channel)
{
unsigned char *id_string, *key, *cipher, *hmac, hash[SILC_HASH_MAXLEN];
SilcUInt32 tmp_len;
SilcChannelID id;
SilcChannelKeyPayload payload;
SILC_LOG_DEBUG(("New channel key"));
payload = silc_channel_key_payload_parse(silc_buffer_data(key_payload),
silc_buffer_len(key_payload));
if (!payload)
return FALSE;
id_string = silc_channel_key_get_id(payload, &tmp_len);
if (!id_string) {
silc_channel_key_payload_free(payload);
return FALSE;
}
if (!silc_id_str2id(id_string, tmp_len, SILC_ID_CHANNEL, &id, sizeof(id))) {
silc_channel_key_payload_free(payload);
return FALSE;
}
/* Find channel. */
if (!channel) {
channel = silc_client_get_channel_by_id(client, conn, &id);
if (!channel) {
SILC_LOG_DEBUG(("Key for unknown channel"));
silc_channel_key_payload_free(payload);
return FALSE;
}
} else {
silc_client_ref_channel(client, conn, channel);
}
/* Save the old key for a short period of time so that we can decrypt
channel message even after the rekey if some client would be sending
messages with the old key after the rekey. */
if (!channel->internal.old_channel_keys)
channel->internal.old_channel_keys = silc_dlist_init();
if (!channel->internal.old_hmacs)
channel->internal.old_hmacs = silc_dlist_init();
if (channel->internal.old_channel_keys && channel->internal.old_hmacs) {
silc_dlist_add(channel->internal.old_channel_keys,
channel->internal.receive_key);
silc_dlist_add(channel->internal.old_hmacs, channel->internal.hmac);
silc_schedule_task_add_timeout(client->schedule,
silc_client_save_channel_key_rekey,
channel, 15, 0);
}
/* Get channel cipher */
cipher = silc_channel_key_get_cipher(payload, NULL);
if (!silc_cipher_alloc(cipher, &channel->internal.send_key)) {
client->internal->ops->say(
conn->client, conn,
SILC_CLIENT_MESSAGE_AUDIT,
"Cannot talk to channel: unsupported cipher %s",
cipher);
silc_client_unref_channel(client, conn, channel);
silc_channel_key_payload_free(payload);
return FALSE;
}
if (!silc_cipher_alloc(cipher, &channel->internal.receive_key)) {
client->internal->ops->say(
conn->client, conn,
SILC_CLIENT_MESSAGE_AUDIT,
"Cannot talk to channel: unsupported cipher %s",
cipher);
silc_client_unref_channel(client, conn, channel);
silc_channel_key_payload_free(payload);
return FALSE;
}
/* Set the cipher key. Both sending and receiving keys are same */
key = silc_channel_key_get_key(payload, &tmp_len);
silc_cipher_set_key(channel->internal.send_key, key, tmp_len * 8, TRUE);
silc_cipher_set_key(channel->internal.receive_key, key, tmp_len * 8, FALSE);
/* Get channel HMAC */
hmac = (channel->internal.hmac ?
(char *)silc_hmac_get_name(channel->internal.hmac) :
SILC_DEFAULT_HMAC);
if (!silc_hmac_alloc(hmac, NULL, &channel->internal.hmac)) {
client->internal->ops->say(
conn->client, conn,
SILC_CLIENT_MESSAGE_AUDIT,
"Cannot talk to channel: unsupported HMAC %s",
hmac);
silc_client_unref_channel(client, conn, channel);
silc_channel_key_payload_free(payload);
return FALSE;
}
channel->cipher = silc_cipher_get_name(channel->internal.send_key);
channel->hmac = silc_hmac_get_name(channel->internal.hmac);
/* Set HMAC key */
silc_hash_make(silc_hmac_get_hash(channel->internal.hmac), key,
tmp_len, hash);
silc_hmac_set_key(channel->internal.hmac, hash,
silc_hash_len(silc_hmac_get_hash(channel->internal.hmac)));
memset(hash, 0, sizeof(hash));
silc_channel_key_payload_free(payload);
silc_client_unref_channel(client, conn, channel);
return TRUE;
}
