int silc_idlist_del_channel(SilcIDList id_list, SilcChannelEntry entry)
{
if (entry) {
/* Remove from cache */
if (!silc_idcache_del_by_context(id_list->channels, entry, NULL)) {
SILC_LOG_DEBUG(("Unknown channel, did not delete"));
return FALSE;
}
SILC_LOG_DEBUG(("Deleting channel %s", entry->channel_name));
/* Free all client entrys from the users list. The silc_hash_table_free
will free all the entries so they are not freed at the foreach
callback. */
silc_hash_table_foreach(entry->user_list, silc_idlist_del_channel_foreach,
NULL);
silc_hash_table_free(entry->user_list);
/* Free data */
silc_free(entry->channel_name);
silc_free(entry->id);
silc_free(entry->topic);
if (entry->invite_list)
silc_hash_table_free(entry->invite_list);
if (entry->ban_list)
silc_hash_table_free(entry->ban_list);
if (entry->send_key)
silc_cipher_free(entry->send_key);
if (entry->receive_key)
silc_cipher_free(entry->receive_key);
if (entry->key) {
memset(entry->key, 0, entry->key_len / 8);
silc_free(entry->key);
}
silc_free(entry->cipher);
if (entry->hmac)
silc_hmac_free(entry->hmac);
silc_free(entry->hmac_name);
silc_free(entry->rekey);
if (entry->founder_key)
silc_pkcs_public_key_free(entry->founder_key);
if (entry->channel_pubkeys)
silc_hash_table_free(entry->channel_pubkeys);
memset(entry, 'F', sizeof(*entry));
silc_free(entry);
return TRUE;
}
return FALSE;
}
SilcChannelEntry
silc_idlist_add_channel(SilcIDList id_list, char *channel_name, int mode,
SilcChannelID *id, SilcServerEntry router,
SilcCipher send_key, SilcCipher receive_key,
SilcHmac hmac)
{
SilcChannelEntry channel;
char *channel_namec = NULL;
SILC_LOG_DEBUG(("Adding new channel %s", channel_name));
/* Normalize name. This is cached, original is in client context. */
if (channel_name) {
channel_namec = silc_channel_name_check(channel_name, strlen(channel_name),
SILC_STRING_UTF8, 256, NULL);
if (!channel_namec)
return NULL;
}
channel = silc_calloc(1, sizeof(*channel));
channel->channel_name = channel_name;
channel->mode = mode;
channel->id = id;
channel->router = router;
channel->send_key = send_key;
channel->receive_key = receive_key;
channel->hmac = hmac;
channel->created = channel->updated = time(0);
if (!channel->hmac)
if (!silc_hmac_alloc(SILC_DEFAULT_HMAC, NULL, &channel->hmac)) {
silc_free(channel);
return NULL;
}
channel->user_list = silc_hash_table_alloc(3, silc_hash_ptr, NULL, NULL,
NULL, NULL, NULL, TRUE);
if (!silc_idcache_add(id_list->channels, channel_namec,
(void *)channel->id, (void *)channel)) {
silc_hmac_free(channel->hmac);
silc_hash_table_free(channel->user_list);
silc_free(channel);
silc_free(channel_namec);
return NULL;
}
return channel;
}
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;
}
int main(int argc, char **argv)
{
SilcBool success = FALSE;
unsigned char digest[20];
SilcUInt32 len;
SilcHmac hmac;
if (argc > 1 && !strcmp(argv[1], "-d")) {
silc_log_debug(TRUE);
silc_log_debug_hexdump(TRUE);
silc_log_set_debug_string("*crypt*,*hash*,*sha1*,*hmac*");
}
SILC_LOG_DEBUG(("Registering builtin hash functions"));
silc_hash_register_default();
silc_hmac_register_default();
SILC_LOG_DEBUG(("Allocating sha1 HMAC"));
if (!silc_hmac_alloc("hmac-sha1", NULL, &hmac)) {
SILC_LOG_DEBUG(("Allocating sha1 HMAC failed"));
goto err;
}
/* First test vector */
SILC_LOG_DEBUG(("First test vector"));
silc_hmac_init_with_key(hmac, key1, key1_len);
silc_hmac_update(hmac, data1, strlen(data1));
silc_hmac_final(hmac, digest, &len);
SILC_LOG_HEXDUMP(("Key"), (unsigned char *)key1, key1_len);
SILC_LOG_HEXDUMP(("Message"), (unsigned char *)data1, strlen(data1));
SILC_LOG_HEXDUMP(("Digest"), digest, len);
SILC_LOG_HEXDUMP(("Expected digest"), (unsigned char *)data1_digest, len);
if (memcmp(digest, data1_digest, len)) {
SILC_LOG_DEBUG(("HMAC failed"));
goto err;
}
SILC_LOG_DEBUG(("HMAC is successful"));
/* Second test vector */
SILC_LOG_DEBUG(("Second test vector"));
silc_hmac_init_with_key(hmac, key2, key2_len);
silc_hmac_update(hmac, data2, strlen(data2));
silc_hmac_final(hmac, digest, &len);
SILC_LOG_HEXDUMP(("Key"), (unsigned char *)key2, key2_len);
SILC_LOG_HEXDUMP(("Message"), (unsigned char *)data2, strlen(data2));
SILC_LOG_HEXDUMP(("Digest"), digest, len);
SILC_LOG_HEXDUMP(("Expected digest"), (unsigned char *)data2_digest, len);
if (memcmp(digest, data2_digest, len)) {
SILC_LOG_DEBUG(("HMAC failed"));
goto err;
}
SILC_LOG_DEBUG(("HMAC is successful"));
/* Third test vector */
SILC_LOG_DEBUG(("Third test vector"));
silc_hmac_init_with_key(hmac, key3, key3_len);
memset(data3, '\xdd', sizeof(data3));
silc_hmac_update(hmac, data3, sizeof(data3));
silc_hmac_final(hmac, digest, &len);
SILC_LOG_HEXDUMP(("Key"), (unsigned char *)key3, key3_len);
SILC_LOG_HEXDUMP(("Message"), (unsigned char *)data3, sizeof(data3));
SILC_LOG_HEXDUMP(("Digest"), digest, len);
SILC_LOG_HEXDUMP(("Expected digest"), (unsigned char *)data3_digest, len);
if (memcmp(digest, data3_digest, len)) {
SILC_LOG_DEBUG(("HMAC failed"));
goto err;
}
SILC_LOG_DEBUG(("HMAC is successful"));
/* Fourth test vector */
SILC_LOG_DEBUG(("Fourth test vector"));
memset(key4, '\xaa', key4_len);
silc_hmac_init_with_key(hmac, key4, key4_len);
silc_hmac_update(hmac, data4, strlen(data4));
silc_hmac_final(hmac, digest, &len);
SILC_LOG_HEXDUMP(("Key"), (unsigned char *)key4, key4_len);
SILC_LOG_HEXDUMP(("Message"), (unsigned char *)data4, sizeof(data4));
SILC_LOG_HEXDUMP(("Digest"), digest, len);
SILC_LOG_HEXDUMP(("Expected digest"), (unsigned char *)data4_digest, len);
if (memcmp(digest, data4_digest, len)) {
SILC_LOG_DEBUG(("HMAC failed"));
goto err;
}
SILC_LOG_DEBUG(("HMAC is successful"));
success = TRUE;
err:
SILC_LOG_DEBUG(("Testing was %s", success ? "SUCCESS" : "FAILURE"));
fprintf(stderr, "Testing was %s\n", success ? "SUCCESS" : "FAILURE");
silc_hmac_free(hmac);
silc_hash_unregister_all();
silc_hmac_unregister_all();
return success;
}
