Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1997 - 2001 Pekka Riikonen
+ Copyright (C) 1997 - 2002 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
static bool
silc_verify_public_key_internal(SilcServer server, SilcSocketConnection sock,
SilcSocketType conn_type,
- unsigned char *pk, uint32 pk_len,
+ unsigned char *pk, SilcUInt32 pk_len,
SilcSKEPKType pk_type)
{
char file[256], filename[256], *fingerprint;
/* The key already exists, verify it. */
SilcPublicKey public_key;
unsigned char *encpk;
- uint32 encpk_len;
+ SilcUInt32 encpk_len;
SILC_LOG_DEBUG(("We have the public key saved locally"));
static void
silc_server_protocol_ke_verify_key(SilcSKE ske,
unsigned char *pk_data,
- uint32 pk_len,
+ SilcUInt32 pk_len,
SilcSKEPKType pk_type,
void *context,
SilcSKEVerifyCbCompletion completion,
if (silc_verify_public_key_internal(server, ctx->sock,
(ctx->responder == FALSE ?
SILC_SOCKET_TYPE_ROUTER:
- ctx->sconfig ? SILC_SOCKET_TYPE_SERVER :
- ctx->rconfig ? SILC_SOCKET_TYPE_ROUTER :
+ ctx->sconfig.ref_ptr ? SILC_SOCKET_TYPE_SERVER :
+ ctx->rconfig.ref_ptr ? SILC_SOCKET_TYPE_ROUTER :
SILC_SOCKET_TYPE_CLIENT),
pk_data, pk_len, pk_type))
completion(ske, SILC_SKE_STATUS_OK, completion_context);
/* Allocate cipher to be used in the communication */
if (!silc_cipher_alloc(cipher->cipher->name, &idata->send_key)) {
silc_free(conn_data);
+ SILC_LOG_ERROR(("Cannot allocate algorithm: %s", cipher->cipher->name));
return FALSE;
}
if (!silc_cipher_alloc(cipher->cipher->name, &idata->receive_key)) {
silc_free(conn_data);
+ SILC_LOG_ERROR(("Cannot allocate algorithm: %s", cipher->cipher->name));
return FALSE;
}
silc_cipher_free(idata->send_key);
silc_cipher_free(idata->receive_key);
silc_free(conn_data);
+ SILC_LOG_ERROR(("Cannot allocate algorithm: %s",
+ silc_hmac_get_name(hmac)));
return FALSE;
}
silc_cipher_free(idata->receive_key);
silc_hmac_free(idata->hmac_send);
silc_free(conn_data);
+ SILC_LOG_ERROR(("Cannot allocate algorithm: %s",
+ silc_hmac_get_name(hmac)));
return FALSE;
}
silc_hmac_free(idata->hmac_send);
silc_hmac_free(idata->hmac_receive);
silc_free(conn_data);
+ SILC_LOG_ERROR(("Cannot allocate algorithm: %s", hash->hash->name));
return FALSE;
}
/* Check remote host version string */
SilcSKEStatus silc_ske_check_version(SilcSKE ske, unsigned char *version,
- uint32 len, void *context)
+ SilcUInt32 len, void *context)
{
SilcSKEStatus status = SILC_SKE_STATUS_OK;
char *cp;
SILC_LOG_INFO(("%s (%s) is version %s", ske->sock->hostname,
ske->sock->ip, version));
- /* Check for initial version string */
- if (!strstr(version, "SILC-1.0-"))
+ /* Check for initial version string. Allowed "SILC-x.x-". More
+ specific protocol version is checked later in session. */
+ if (!strstr(version, "SILC-"))
status = SILC_SKE_STATUS_BAD_VERSION;
/* Check software version */
if (maj != maj2)
status = SILC_SKE_STATUS_BAD_VERSION;
-#if 0
- if (min > min2)
- status = SILC_SKE_STATUS_BAD_VERSION;
-#endif
-
- /* XXX < 0.6 is not allowed */
- if (maj == 0 && min < 5)
- status = SILC_SKE_STATUS_BAD_VERSION;
- /* XXX backward support for 0.6.1 */
- if (maj == 0 && min == 6 && build < 2)
- ske->backward_version = 1;
+ if (status == SILC_SKE_STATUS_BAD_VERSION)
+ SILC_LOG_ERROR(("%s (%s) %s is not allowed/supported version",
+ ske->sock->hostname, ske->sock->ip, version));
return status;
}
SILC_LOG_DEBUG(("Start"));
if (ske->status != SILC_SKE_STATUS_OK) {
- SILC_LOG_WARNING(("Error (%s) during Key Exchange protocol",
- silc_ske_map_status(ske->status)));
- SILC_LOG_DEBUG(("Error (%s) during Key Exchange protocol",
+ SILC_LOG_ERROR(("Error (%s) during Key Exchange protocol",
silc_ske_map_status(ske->status)));
-
+
protocol->state = SILC_PROTOCOL_STATE_ERROR;
silc_protocol_execute(protocol, server->schedule, 0, 300000);
return;
return;
if (status != SILC_SKE_STATUS_OK) {
- SILC_LOG_WARNING(("Error (%s) during Key Exchange protocol",
- silc_ske_map_status(status)));
- SILC_LOG_DEBUG(("Error (%s) during Key Exchange protocol",
+ SILC_LOG_ERROR(("Error (%s) during Key Exchange protocol",
silc_ske_map_status(status)));
protocol->state = SILC_PROTOCOL_STATE_ERROR;
return;
if (status != SILC_SKE_STATUS_OK) {
- SILC_LOG_WARNING(("Error (%s) during Key Exchange protocol",
- silc_ske_map_status(status)));
- SILC_LOG_DEBUG(("Error (%s) during Key Exchange protocol",
+ SILC_LOG_ERROR(("Error (%s) during Key Exchange protocol",
silc_ske_map_status(status)));
protocol->state = SILC_PROTOCOL_STATE_ERROR;
return;
if (status != SILC_SKE_STATUS_OK) {
- SILC_LOG_WARNING(("Error (%s) during Key Exchange protocol",
- silc_ske_map_status(status)));
- SILC_LOG_DEBUG(("Error (%s) during Key Exchange protocol",
+ SILC_LOG_ERROR(("Error (%s) during Key Exchange protocol",
silc_ske_map_status(status)));
protocol->state = SILC_PROTOCOL_STATE_ERROR;
return;
if (status != SILC_SKE_STATUS_OK) {
- SILC_LOG_WARNING(("Error (%s) during Key Exchange protocol",
- silc_ske_map_status(status)));
- SILC_LOG_DEBUG(("Error (%s) during Key Exchange protocol",
+ SILC_LOG_ERROR(("Error (%s) during Key Exchange protocol",
silc_ske_map_status(status)));
protocol->state = SILC_PROTOCOL_STATE_ERROR;
status = silc_ske_process_key_material(ctx->ske, 16, key_len, hash_len,
keymat);
if (status != SILC_SKE_STATUS_OK) {
+ SILC_LOG_ERROR(("Error during Key Exchange protocol: "
+ "could not process key material"));
+
protocol->state = SILC_PROTOCOL_STATE_ERROR;
silc_protocol_execute(protocol, server->schedule, 0, 300000);
silc_ske_free_key_material(keymat);
silc_server_public_key_authentication(SilcServer server,
SilcPublicKey pub_key,
unsigned char *sign,
- uint32 sign_len,
+ SilcUInt32 sign_len,
SilcSKE ske)
{
SilcPKCS pkcs;
static int
silc_server_get_public_key_auth(SilcServer server,
unsigned char **auth_data,
- uint32 *auth_data_len,
+ SilcUInt32 *auth_data_len,
SilcSKE ske)
{
int len;
static bool
silc_server_get_authentication(SilcServerConnAuthInternalContext *ctx,
char *local_passphrase,
- void *local_publickey,
+ SilcHashTable local_publickeys,
unsigned char *remote_auth,
- uint32 remote_auth_len)
+ SilcUInt32 remote_auth_len)
{
SilcServer server = (SilcServer)ctx->server;
SilcSKE ske = ctx->ske;
/* If we don't have authentication data set at all we do not require
authentication at all */
- if (!local_passphrase && !local_publickey) {
+ if (!local_passphrase && (!local_publickeys ||
+ !silc_hash_table_count(local_publickeys))) {
SILC_LOG_DEBUG(("No authentication required"));
return TRUE;
}
}
/* Try public key authenetication */
- if (!result && local_publickey) {
+ if (!result && local_publickeys) {
+ SilcPublicKey cached_key;
+ SilcPublicKey remote_key =
+ ((SilcIDListData)ctx->sock->user_data)->public_key;
+
SILC_LOG_DEBUG(("Public key authentication"));
- result = silc_server_public_key_authentication(server,
- local_publickey,
+
+ /* Find the public key to be used in authentication */
+ cached_key = silc_server_find_public_key(server, local_publickeys,
+ remote_key);
+ if (!cached_key)
+ return FALSE;
+
+ result = silc_server_public_key_authentication(server, cached_key,
remote_auth,
- remote_auth_len,
- ske);
+ remote_auth_len, ske);
}
return result;
* We are receiving party
*/
int ret;
- uint16 payload_len;
- uint16 conn_type;
+ SilcUInt16 payload_len;
+ SilcUInt16 conn_type;
unsigned char *auth_data = NULL;
SILC_LOG_INFO(("Performing authentication protocol for %s (%s)",
SILC_STR_UI_SHORT(&conn_type),
SILC_STR_END);
if (ret == -1) {
- SILC_LOG_DEBUG(("Bad payload in authentication packet"));
+ SILC_LOG_ERROR(("Bad payload in authentication packet"));
protocol->state = SILC_PROTOCOL_STATE_ERROR;
silc_protocol_execute(protocol, server->schedule, 0, 300000);
return;
}
if (payload_len != ctx->packet->buffer->len) {
- SILC_LOG_DEBUG(("Bad payload in authentication packet"));
+ SILC_LOG_ERROR(("Bad payload length in authentication packet"));
protocol->state = SILC_PROTOCOL_STATE_ERROR;
silc_protocol_execute(protocol, server->schedule, 0, 300000);
return;
if (conn_type < SILC_SOCKET_TYPE_CLIENT ||
conn_type > SILC_SOCKET_TYPE_ROUTER) {
- SILC_LOG_ERROR(("Bad connection type %d", conn_type));
+ SILC_LOG_ERROR(("Bad connection type (%d) in authentication packet",
+ conn_type));
protocol->state = SILC_PROTOCOL_STATE_ERROR;
silc_protocol_execute(protocol, server->schedule, 0, 300000);
return;
payload_len),
SILC_STR_END);
if (ret == -1) {
- SILC_LOG_DEBUG(("Bad payload in authentication packet"));
+ SILC_LOG_DEBUG(("Bad payload in authentication payload"));
protocol->state = SILC_PROTOCOL_STATE_ERROR;
silc_protocol_execute(protocol, server->schedule, 0, 300000);
return;
/* Remote end is client */
if (conn_type == SILC_SOCKET_TYPE_CLIENT) {
- SilcServerConfigClient *client = ctx->cconfig;
-
+ SilcServerConfigClient *client = ctx->cconfig.ref_ptr;
+
if (client) {
ret = silc_server_get_authentication(ctx, client->passphrase,
- client->publickey,
+ client->publickeys,
auth_data, payload_len);
if (!ret) {
/* Authentication failed */
SILC_LOG_ERROR(("Authentication failed"));
- SILC_LOG_DEBUG(("Authentication failed"));
silc_free(auth_data);
protocol->state = SILC_PROTOCOL_STATE_ERROR;
silc_protocol_execute(protocol, server->schedule, 0, 300000);
return;
}
} else {
- SILC_LOG_DEBUG(("No configuration for remote client connection"));
SILC_LOG_ERROR(("Remote client connection not configured"));
SILC_LOG_ERROR(("Authentication failed"));
silc_free(auth_data);
/* Remote end is server */
if (conn_type == SILC_SOCKET_TYPE_SERVER) {
- SilcServerConfigServer *serv = ctx->sconfig;
-
+ SilcServerConfigServer *serv = ctx->sconfig.ref_ptr;
+
if (serv) {
ret = silc_server_get_authentication(ctx, serv->passphrase,
- serv->publickey,
+ serv->publickeys,
auth_data, payload_len);
if (!ret) {
/* Authentication failed */
SILC_LOG_ERROR(("Authentication failed"));
- SILC_LOG_DEBUG(("Authentication failed"));
silc_free(auth_data);
protocol->state = SILC_PROTOCOL_STATE_ERROR;
silc_protocol_execute(protocol, server->schedule, 0, 300000);
return;
}
} else {
- SILC_LOG_DEBUG(("No configuration for remote server connection"));
SILC_LOG_ERROR(("Remote server connection not configured"));
SILC_LOG_ERROR(("Authentication failed"));
protocol->state = SILC_PROTOCOL_STATE_ERROR;
/* Remote end is router */
if (conn_type == SILC_SOCKET_TYPE_ROUTER) {
- SilcServerConfigRouter *serv = ctx->rconfig;
+ SilcServerConfigRouter *serv = ctx->rconfig.ref_ptr;
if (serv) {
ret = silc_server_get_authentication(ctx, serv->passphrase,
- serv->publickey,
+ serv->publickeys,
auth_data, payload_len);
if (!ret) {
/* Authentication failed */
SILC_LOG_ERROR(("Authentication failed"));
- SILC_LOG_DEBUG(("Authentication failed"));
silc_free(auth_data);
protocol->state = SILC_PROTOCOL_STATE_ERROR;
silc_protocol_execute(protocol, server->schedule, 0, 300000);
return;
}
} else {
- SILC_LOG_DEBUG(("No configuration for remote router connection"));
SILC_LOG_ERROR(("Remote router connection not configured"));
SILC_LOG_ERROR(("Authentication failed"));
silc_free(auth_data);
SilcBuffer packet;
int payload_len = 0;
unsigned char *auth_data = NULL;
- uint32 auth_data_len = 0;
+ SilcUInt32 auth_data_len = 0;
switch(ctx->auth_meth) {
case SILC_AUTH_NONE:
*/
unsigned char error[4];
- SILC_PUT32_MSB(SILC_AUTH_FAILED, error);
-
/* Authentication failed */
+ SILC_PUT32_MSB(SILC_AUTH_FAILED, error);
silc_server_packet_send(server, ctx->sock, SILC_PACKET_FAILURE,
0, error, 4, TRUE);
* We have received failure from remote
*/
+ SILC_LOG_ERROR(("Received Authentication Failure"));
+
/* Unregister the timeout task since the protocol has ended.
This was the timeout task to be executed if the protocol is
not completed fast enough. */
{
SilcIDListData idata = (SilcIDListData)ctx->sock->user_data;
SilcSKEKeyMaterial *keymat;
- uint32 key_len = silc_cipher_get_key_len(idata->send_key);
- uint32 hash_len = idata->hash->hash->hash_len;
+ SilcUInt32 key_len = silc_cipher_get_key_len(idata->send_key);
+ SilcUInt32 hash_len = idata->hash->hash->hash_len;
SILC_LOG_DEBUG(("Generating new %s session keys (no PFS)",
send ? "sending" : "receiving"));
{
SilcIDListData idata = (SilcIDListData)ctx->sock->user_data;
SilcSKEKeyMaterial *keymat;
- uint32 key_len = silc_cipher_get_key_len(idata->send_key);
- uint32 hash_len = idata->hash->hash->hash_len;
+ SilcUInt32 key_len = silc_cipher_get_key_len(idata->send_key);
+ SilcUInt32 hash_len = idata->hash->hash->hash_len;
unsigned char *tmpbuf;
- uint32 klen;
+ SilcUInt32 klen;
SILC_LOG_DEBUG(("Generating new %s session keys (with PFS)",
send ? "sending" : "receiving"));
*/
if (ctx->packet->type != SILC_PACKET_KEY_EXCHANGE_1) {
- /* Error in protocol */
+ SILC_LOG_ERROR(("Error during Re-key (PFS): re-key state is "
+ "incorrect (received %d, expected %d packet)",
+ ctx->packet->type, SILC_PACKET_KEY_EXCHANGE_1));
protocol->state = SILC_PROTOCOL_STATE_ERROR;
silc_protocol_execute(protocol, server->schedule, 0, 300000);
return;
status = silc_ske_responder_phase_2(ctx->ske, ctx->packet->buffer);
if (status != SILC_SKE_STATUS_OK) {
- SILC_LOG_WARNING(("Error (%s) during Re-key (PFS)",
- silc_ske_map_status(status)));
-
+ SILC_LOG_ERROR(("Error (%s) during Re-key (PFS)",
+ silc_ske_map_status(status)));
protocol->state = SILC_PROTOCOL_STATE_ERROR;
silc_protocol_execute(protocol, server->schedule, 0, 300000);
return;
status = silc_ske_initiator_phase_2(ctx->ske, NULL, NULL, 0);
if (status != SILC_SKE_STATUS_OK) {
- SILC_LOG_WARNING(("Error (%s) during Re-key (PFS)",
- silc_ske_map_status(status)));
-
+ SILC_LOG_ERROR(("Error (%s) during Re-key (PFS)",
+ silc_ske_map_status(status)));
protocol->state = SILC_PROTOCOL_STATE_ERROR;
silc_protocol_execute(protocol, server->schedule, 0, 300000);
return;
status = silc_ske_responder_finish(ctx->ske, NULL, NULL,
SILC_SKE_PK_TYPE_SILC);
if (status != SILC_SKE_STATUS_OK) {
- SILC_LOG_WARNING(("Error (%s) during Re-key (PFS)",
- silc_ske_map_status(status)));
-
+ SILC_LOG_ERROR(("Error (%s) during Re-key (PFS)",
+ silc_ske_map_status(status)));
protocol->state = SILC_PROTOCOL_STATE_ERROR;
silc_protocol_execute(protocol, server->schedule, 0, 300000);
return;
* The packet type must be KE packet
*/
if (ctx->packet->type != SILC_PACKET_KEY_EXCHANGE_2) {
- /* Error in protocol */
+ SILC_LOG_ERROR(("Error during Re-key (PFS): re-key state is "
+ "incorrect (received %d, expected %d packet)",
+ ctx->packet->type, SILC_PACKET_KEY_EXCHANGE_2));
protocol->state = SILC_PROTOCOL_STATE_ERROR;
silc_protocol_execute(protocol, server->schedule, 0, 300000);
return;
status = silc_ske_initiator_finish(ctx->ske, ctx->packet->buffer);
if (status != SILC_SKE_STATUS_OK) {
- SILC_LOG_WARNING(("Error (%s) during Re-key (PFS)",
- silc_ske_map_status(status)));
-
+ SILC_LOG_ERROR(("Error (%s) during Re-key (PFS)",
+ silc_ske_map_status(status)));
protocol->state = SILC_PROTOCOL_STATE_ERROR;
silc_protocol_execute(protocol, server->schedule, 0, 300000);
return;
*/
if (ctx->packet->type != SILC_PACKET_REKEY_DONE) {
- /* Error in protocol */
+ SILC_LOG_ERROR(("Error during Re-key (PFS): re-key state is "
+ "incorrect (received %d, expected %d packet)",
+ ctx->packet->type, SILC_PACKET_REKEY_DONE));
protocol->state = SILC_PROTOCOL_STATE_ERROR;
silc_protocol_execute(protocol, server->schedule, 0, 300000);
return;
* Error occured
*/
- if (ctx->pfs == TRUE) {
+ if (ctx->pfs == TRUE)
/* Send abort notification */
silc_ske_abort(ctx->ske, ctx->ske->status);
- }
/* Assure that after calling final callback there cannot be pending
executions for this protocol anymore. This just unregisters any
* We have received failure from remote
*/
+ SILC_LOG_ERROR(("Error during Re-Key: received Failure"));
+
/* Assure that after calling final callback there cannot be pending
executions for this protocol anymore. This just unregisters any
timeout callbacks for this protocol. */
projects / silc.git / blobdiff