/* 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;
}
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);
static bool
silc_server_get_authentication(SilcServerConnAuthInternalContext *ctx,
char *local_passphrase,
- void *local_publickey,
+ SilcHashTable local_publickeys,
unsigned char *remote_auth,
SilcUInt32 remote_auth_len)
{
/* 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;
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;
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);
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;
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);
*/
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. */
*/
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