/* client_prvmsg.c Author: Pekka Riikonen Copyright (C) 1997 - 2007 Pekka Riikonen This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; version 2 of the License. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. */ /* $Id$ */ #include "silc.h" #include "silcclient.h" #include "client_internal.h" /************************** Private Message Send ****************************/ typedef struct { SilcClient client; SilcClientConnection conn; SilcClientEntry client_entry; } *SilcClientPrvmsgContext; /* Message payload encoding callback */ static void silc_client_send_private_message_final(SilcBuffer message, void *context) { SilcClientPrvmsgContext p = context; /* Send the private message packet */ if (message) silc_packet_send_ext(p->conn->stream, SILC_PACKET_PRIVATE_MESSAGE, p->client_entry->internal.send_key ? SILC_PACKET_FLAG_PRIVMSG_KEY : 0, 0, NULL, SILC_ID_CLIENT, &p->client_entry->id, silc_buffer_datalen(message), NULL, NULL); silc_client_unref_client(p->client, p->conn, p->client_entry); silc_free(p); } /* Sends private message to remote client. */ SilcBool silc_client_send_private_message(SilcClient client, SilcClientConnection conn, SilcClientEntry client_entry, SilcMessageFlags flags, SilcHash hash, unsigned char *data, SilcUInt32 data_len) { SilcClientPrvmsgContext p; SilcID sid, rid; if (silc_unlikely(!client || !conn || !client_entry)) return FALSE; if (silc_unlikely(flags & SILC_MESSAGE_FLAG_SIGNED && !hash)) { SILC_LOG_ERROR(("Cannot send signed message without hash, missing " "arguments")); return FALSE; } if (silc_unlikely(conn->internal->disconnected)) return FALSE; SILC_LOG_DEBUG(("Sending private message")); sid.type = SILC_ID_CLIENT; sid.u.client_id = conn->local_entry->id; rid.type = SILC_ID_CLIENT; rid.u.client_id = client_entry->id; p = silc_calloc(1, sizeof(*p)); if (!p) return FALSE; p->client = client; p->conn = conn; p->client_entry = silc_client_ref_client(client, conn, client_entry); /* Encode private message payload */ silc_message_payload_encode(flags, data, data_len, (!client_entry->internal.send_key ? FALSE : !client_entry->internal.generated), TRUE, client_entry->internal.send_key, client_entry->internal.hmac_send, client->rng, NULL, conn->private_key, hash, &sid, &rid, NULL, silc_client_send_private_message_final, p); return TRUE; } /************************* Private Message Receive **************************/ /* Client resolving callback. Continues with the private message processing */ static void silc_client_private_message_resolved(SilcClient client, SilcClientConnection conn, SilcStatus status, SilcDList clients, void *context) { /* If no client found, ignore the private message, a silent error */ if (!clients) silc_fsm_next(context, silc_client_private_message_error); /* Continue processing the private message packet */ SILC_FSM_CALL_CONTINUE(context); } /* Private message received. */ SILC_FSM_STATE(silc_client_private_message) { SilcClientConnection conn = fsm_context; SilcClient client = conn->client; SilcPacket packet = state_context; SilcMessagePayload payload = NULL; SilcClientID remote_id; SilcClientEntry remote_client = NULL; SilcMessageFlags flags; unsigned char *message; SilcUInt32 message_len; SILC_LOG_DEBUG(("Received private message")); if (silc_unlikely(packet->src_id_type != SILC_ID_CLIENT)) { /** Invalid packet */ silc_fsm_next(fsm, silc_client_private_message_error); return SILC_FSM_CONTINUE; } if (silc_unlikely(!silc_id_str2id(packet->src_id, packet->src_id_len, SILC_ID_CLIENT, &remote_id, sizeof(remote_id)))) { /** Invalid source ID */ silc_fsm_next(fsm, silc_client_private_message_error); return SILC_FSM_CONTINUE; } /* Check whether we know this client already */ remote_client = silc_client_get_client_by_id(client, conn, &remote_id); if (!remote_client || !remote_client->nickname[0]) { /** Resolve client info */ silc_client_unref_client(client, conn, remote_client); SILC_FSM_CALL(silc_client_get_client_by_id_resolve( client, conn, &remote_id, NULL, silc_client_private_message_resolved, fsm)); /* NOT REACHED */ } if (silc_unlikely(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY && !remote_client->internal.receive_key && !remote_client->internal.hmac_receive)) goto out; /* Parse the payload and decrypt it also if private message key is set */ payload = silc_message_payload_parse(silc_buffer_datalen(&packet->buffer), TRUE, !remote_client->internal.generated, remote_client->internal.receive_key, remote_client->internal.hmac_receive, packet->src_id, packet->src_id_len, packet->dst_id, packet->dst_id_len, NULL, FALSE, NULL); if (silc_unlikely(!payload)) goto out; /* Pass the private message to application */ flags = silc_message_get_flags(payload); message = silc_message_get_data(payload, &message_len); client->internal->ops->private_message(client, conn, remote_client, payload, flags, message, message_len); /* See if we are away (gone). If we are away we will reply to the sender with the set away message. */ if (conn->internal->away_message && !(flags & SILC_MESSAGE_FLAG_NOREPLY)) { /* If it's me, ignore */ if (SILC_ID_CLIENT_COMPARE(&remote_id, conn->local_id)) goto out; /* Send the away message */ silc_client_send_private_message(client, conn, remote_client, SILC_MESSAGE_FLAG_AUTOREPLY | SILC_MESSAGE_FLAG_NOREPLY, NULL, conn->internal->away_message, strlen(conn->internal->away_message)); } out: /** Packet processed */ silc_packet_free(packet); silc_client_unref_client(client, conn, remote_client); if (payload) silc_message_payload_free(payload); return SILC_FSM_FINISH; } /* Private message error. */ SILC_FSM_STATE(silc_client_private_message_error) { SilcPacket packet = state_context; silc_packet_free(packet); return SILC_FSM_FINISH; } /* Initialize private message waiter for the `conn' connection. */ SilcBool silc_client_private_message_wait_init(SilcClient client, SilcClientConnection conn, SilcClientEntry client_entry) { SilcID id; if (client_entry->internal.prv_waiter) return TRUE; /* We want SILC_PACKET_PRIVATE_MESSAGE packets from this source ID. */ id.type = SILC_ID_CLIENT; id.u.client_id = client_entry->id; client_entry->internal.prv_waiter = silc_packet_wait_init(conn->stream, &id, SILC_PACKET_PRIVATE_MESSAGE, -1); if (!client_entry->internal.prv_waiter) return FALSE; return TRUE; } /* Uninitializes private message waiter. */ void silc_client_private_message_wait_uninit(SilcClient client, SilcClientConnection conn, SilcClientEntry client_entry) { if (!client_entry->internal.prv_waiter) return; silc_packet_wait_uninit(client_entry->internal.prv_waiter, conn->stream); client_entry->internal.prv_waiter = NULL; } /* Blocks the calling process or thread until private message has been received from the specified client. */ SilcBool silc_client_private_message_wait(SilcClient client, SilcClientConnection conn, SilcClientEntry client_entry, SilcMessagePayload *payload) { SilcPacket packet; if (!client_entry->internal.prv_waiter) return FALSE; /* Block until private message arrives */ do { if ((silc_packet_wait(client_entry->internal.prv_waiter, 0, &packet)) < 0) return FALSE; /* Parse the payload and decrypt it also if private message key is set */ *payload = silc_message_payload_parse(silc_buffer_data(&packet->buffer), silc_buffer_len(&packet->buffer), TRUE, !client_entry->internal.generated, client_entry->internal.receive_key, client_entry->internal.hmac_receive, packet->src_id, packet->src_id_len, packet->dst_id, packet->dst_id_len, NULL, FALSE, NULL); if (!(*payload)) { silc_packet_free(packet); continue; } break; } while (1); silc_packet_free(packet); return TRUE; } /*************************** Private Message Key ****************************/ /* Sends private message key request. Sender of this packet is initiator when setting the private message key. */ 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); } /* Client resolving callback. Here we simply mark that we are the responder side of this private message key request. */ static void silc_client_private_message_key_cb(SilcClient client, SilcClientConnection conn, SilcStatus status, SilcDList clients, void *context) { SilcFSMThread thread = context; SilcPacket packet = silc_fsm_get_state_context(thread); unsigned char *cipher = NULL, *hmac = NULL; SilcClientEntry client_entry; int ret; if (!clients) { silc_packet_free(packet); silc_fsm_finish(thread); return; } /* Parse the private message key payload */ ret = silc_buffer_unformat(&packet->buffer, SILC_STR_UI16_STRING_ALLOC(&cipher), SILC_STR_UI16_STRING_ALLOC(&hmac), SILC_STR_END); if (!ret) goto out; /* Mark that we are responder */ client_entry = silc_dlist_get(clients); client_entry->internal.prv_resp = TRUE; /* XXX we should notify application that remote wants to set up the static key. And we should tell if we already have key with remote. Application should return status telling whether to delete the key or not. */ out: silc_free(cipher); silc_free(hmac); silc_packet_free(packet); silc_fsm_finish(thread); } /* Processes incoming Private Message Key payload to indicate that the sender whishes to set up a static private message key. */ SILC_FSM_STATE(silc_client_private_message_key) { SilcClientConnection conn = fsm_context; SilcClient client = conn->client; SilcPacket packet = state_context; SilcClientID remote_id; if (packet->src_id_type != SILC_ID_CLIENT) { silc_packet_free(packet); return SILC_FSM_FINISH; } if (!silc_id_str2id(packet->src_id, packet->src_id_len, SILC_ID_CLIENT, &remote_id, sizeof(remote_id))) { silc_packet_free(packet); return SILC_FSM_FINISH; } /* Always resolve the remote client. The actual packet is processed in the resolving callback. */ SILC_FSM_CALL(silc_client_get_client_by_id_resolve( client, conn, &remote_id, NULL, silc_client_private_message_key_cb, fsm)); } /* Adds new private message key to `client_entry'. If we are setting this before receiving request for it from `client_entry' we will send the request to the client. Otherwise, we are responder side. */ SilcBool silc_client_add_private_message_key(SilcClient client, SilcClientConnection conn, SilcClientEntry client_entry, const char *cipher, const char *hmac, unsigned char *key, SilcUInt32 key_len) { SilcSKEKeyMaterial keymat; SilcBool ret; if (!client || !client_entry) return FALSE; /* Return FALSE if key already set */ if (client_entry->internal.send_key && client_entry->internal.receive_key) return FALSE; if (!cipher) cipher = SILC_DEFAULT_CIPHER; if (!hmac) hmac = SILC_DEFAULT_HMAC; /* Check the requested cipher and HMAC */ if (!silc_cipher_is_supported(cipher)) return FALSE; if (!silc_hmac_is_supported(hmac)) return FALSE; /* Save the key */ client_entry->internal.key = silc_memdup(key, key_len); client_entry->internal.key_len = key_len; /* Produce the key material as the protocol defines */ keymat = silc_ske_process_key_material_data(key, key_len, 16, 256, 16, conn->internal->sha1hash); if (!keymat) return FALSE; /* Set the key into use */ ret = silc_client_add_private_message_key_ske(client, conn, client_entry, cipher, hmac, keymat); client_entry->internal.generated = FALSE; /* Free the key material */ silc_ske_free_key_material(keymat); /* If we are setting the key without a request from the remote client, we will send request to remote. */ if (!client_entry->internal.prv_resp) silc_client_send_private_message_key_request(client, conn, client_entry); return ret; } /* Same as above but takes the key material from the SKE key material structure. */ SilcBool silc_client_add_private_message_key_ske(SilcClient client, SilcClientConnection conn, SilcClientEntry client_entry, const char *cipher, const char *hmac, SilcSKEKeyMaterial keymat) { if (!client || !client_entry) return FALSE; /* Return FALSE if key already set */ if (client_entry->internal.send_key && client_entry->internal.receive_key) return FALSE; if (!cipher) cipher = SILC_DEFAULT_CIPHER; if (!hmac) hmac = SILC_DEFAULT_HMAC; /* Check the requested cipher and HMAC */ if (!silc_cipher_is_supported(cipher)) return FALSE; if (!silc_hmac_is_supported(hmac)) return FALSE; client_entry->internal.generated = TRUE; /* Allocate the cipher and HMAC */ if (!silc_cipher_alloc(cipher, &client_entry->internal.send_key)) return FALSE; if (!silc_cipher_alloc(cipher, &client_entry->internal.receive_key)) return FALSE; if (!silc_hmac_alloc(hmac, NULL, &client_entry->internal.hmac_send)) return FALSE; if (!silc_hmac_alloc(hmac, NULL, &client_entry->internal.hmac_receive)) return FALSE; /* Set the keys */ if (client_entry->internal.prv_resp) { silc_cipher_set_key(client_entry->internal.send_key, keymat->receive_enc_key, keymat->enc_key_len, TRUE); silc_cipher_set_iv(client_entry->internal.send_key, keymat->receive_iv); silc_cipher_set_key(client_entry->internal.receive_key, keymat->send_enc_key, keymat->enc_key_len, FALSE); silc_cipher_set_iv(client_entry->internal.receive_key, keymat->send_iv); silc_hmac_set_key(client_entry->internal.hmac_send, keymat->receive_hmac_key, keymat->hmac_key_len); silc_hmac_set_key(client_entry->internal.hmac_receive, keymat->send_hmac_key, keymat->hmac_key_len); } else { silc_cipher_set_key(client_entry->internal.send_key, keymat->send_enc_key, keymat->enc_key_len, TRUE); silc_cipher_set_iv(client_entry->internal.send_key, keymat->send_iv); silc_cipher_set_key(client_entry->internal.receive_key, keymat->receive_enc_key, keymat->enc_key_len, FALSE); silc_cipher_set_iv(client_entry->internal.receive_key, keymat->receive_iv); silc_hmac_set_key(client_entry->internal.hmac_send, keymat->send_hmac_key, keymat->hmac_key_len); silc_hmac_set_key(client_entry->internal.hmac_receive, keymat->receive_hmac_key, keymat->hmac_key_len); } return TRUE; } /* Removes the private message from the library. The key won't be used after this to protect the private messages with the remote `client_entry' client. Returns FALSE on error, TRUE otherwise. */ SilcBool silc_client_del_private_message_key(SilcClient client, SilcClientConnection conn, SilcClientEntry client_entry) { if (!client || !client_entry) return FALSE; if (!client_entry->internal.send_key && !client_entry->internal.receive_key) return FALSE; silc_cipher_free(client_entry->internal.send_key); silc_cipher_free(client_entry->internal.receive_key); if (client_entry->internal.key) { memset(client_entry->internal.key, 0, client_entry->internal.key_len); silc_free(client_entry->internal.key); } client_entry->internal.send_key = NULL; client_entry->internal.receive_key = NULL; client_entry->internal.key = NULL; client_entry->internal.prv_resp = FALSE; return TRUE; } /* Returns array of set private message keys associated to the connection `conn'. Returns allocated SilcPrivateMessageKeys array and the array count to the `key_count' argument. The array must be freed by the caller by calling the silc_client_free_private_message_keys function. Note: the keys returned in the array is in raw format. It might not be desired to show the keys as is. The application might choose not to show the keys at all or to show the fingerprints of the keys. */ SilcPrivateMessageKeys silc_client_list_private_message_keys(SilcClient client, SilcClientConnection conn, SilcUInt32 *key_count) { SilcPrivateMessageKeys keys; SilcUInt32 count = 0; SilcList list; SilcIDCacheEntry id_cache; SilcClientEntry entry; if (!client || !conn) return NULL; silc_mutex_lock(conn->internal->lock); if (!silc_idcache_get_all(conn->internal->client_cache, &list)) { silc_mutex_unlock(conn->internal->lock); return NULL; } keys = silc_calloc(silc_list_count(list), sizeof(*keys)); if (!keys) { silc_mutex_unlock(conn->internal->lock); return NULL; } silc_list_start(list); while ((id_cache = silc_list_get(list))) { entry = id_cache->context; if (entry->internal.send_key) { keys[count].client_entry = entry; keys[count].cipher = (char *)silc_cipher_get_name(entry->internal. send_key); keys[count].key = (entry->internal.generated == FALSE ? entry->internal.key : NULL); keys[count].key_len = (entry->internal.generated == FALSE ? entry->internal.key_len : 0); count++; } } silc_mutex_unlock(conn->internal->lock); if (key_count) *key_count = count; return keys; } /* Frees the SilcPrivateMessageKeys array returned by the function silc_client_list_private_message_keys. */ void silc_client_free_private_message_keys(SilcPrivateMessageKeys keys, SilcUInt32 key_count) { silc_free(keys); } /* Return private message key from the client entry. */ SilcBool silc_client_private_message_key_is_set(SilcClient client, SilcClientConnection conn, SilcClientEntry client_entry) { return client_entry->internal.send_key != NULL; } /* Sets away `message'. The away message may be set when the client's mode is changed to SILC_UMODE_GONE and the client whishes to reply to anyone who sends private message. The `message' will be sent automatically back to the the client who send private message. If away message is already set this replaces the old message with the new one. If `message' is NULL the old away message is removed. The sender may freely free the memory of the `message'. */ SilcBool silc_client_set_away_message(SilcClient client, SilcClientConnection conn, char *message) { if (!client || !conn) return FALSE; if (!message) { silc_free(conn->internal->away_message); conn->internal->away_message = NULL; return TRUE; } if (conn->internal->away_message) silc_free(conn->internal->away_message); conn->internal->away_message = strdup(message); if (!conn->internal->away_message) return FALSE; return TRUE; }