void initsilc() {
PyObject *mod = Py_InitModule3("silc", pysilc_functions, pysilc_doc);
silc_pkcs_register_default();
silc_hash_register_default();
silc_cipher_register_default();
silc_hmac_register_default();
PY_MOD_ADD_CLASS(mod, SilcClient);
PY_MOD_ADD_CLASS(mod, SilcChannel);
PY_MOD_ADD_CLASS(mod, SilcUser);
PyModule_AddIntConstant(mod, "SILC_ID_CLIENT", SILC_ID_CLIENT);
PyModule_AddIntConstant(mod, "SILC_ID_CHANNEL", SILC_ID_CHANNEL);
PyModule_AddIntConstant(mod, "SILC_ID_SERVER", SILC_ID_SERVER);
}
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;
}
SilcBool silc_client_init(SilcClient client, const char *username,
const char *hostname, const char *realname,
SilcClientRunning running, void *context)
{
SILC_LOG_DEBUG(("Initializing client"));
if (!client)
return FALSE;
if (!username || !hostname) {
SILC_LOG_ERROR(("Username and hostname must be given to "
"silc_client_init"));
return FALSE;
}
if (!realname)
realname = username;
/* Validate essential strings */
if (!silc_identifier_verify(username, strlen(username),
SILC_STRING_UTF8, 128)) {
SILC_LOG_ERROR(("Malformed username '%s'. Username must be UTF-8 string",
client->username));
return FALSE;
}
if (!silc_identifier_verify(hostname, strlen(hostname),
SILC_STRING_UTF8, 256)) {
SILC_LOG_ERROR(("Malformed hostname '%s'. Hostname must be UTF-8 string",
client->hostname));
return FALSE;
}
if (!silc_utf8_valid(realname, strlen(realname))) {
SILC_LOG_ERROR(("Malformed realname '%s'. Realname must be UTF-8 string",
client->realname));
return FALSE;
}
/* Take the name strings */
client->username = strdup(username);
client->hostname = strdup(hostname);
client->realname = strdup(realname);
if (!username || !hostname || !realname)
return FALSE;
client->internal->ftp_sessions = silc_dlist_init();
if (!client->internal->ftp_sessions)
return FALSE;
if (!client->internal->params->dont_register_crypto_library) {
/* Initialize the crypto library. If application has done this already
this has no effect. Also, we will not be overriding something
application might have registered earlier. */
silc_cipher_register_default();
silc_pkcs_register_default();
silc_hash_register_default();
silc_hmac_register_default();
}
/* Initialize random number generator */
client->rng = silc_rng_alloc();
if (!client->rng)
return FALSE;
silc_rng_init(client->rng);
silc_rng_global_init(client->rng);
/* Initialize the scheduler */
client->schedule = silc_schedule_init(0, client);
if (!client->schedule)
return FALSE;
/* Allocate client lock */
silc_mutex_alloc(&client->internal->lock);
/* Register commands */
silc_client_commands_register(client);
/* Start packet engine */
client->internal->packet_engine =
silc_packet_engine_start(client->rng, FALSE, &silc_client_stream_cbs,
client);
if (!client->internal->packet_engine)
return FALSE;
/* Initialize and start the client FSM */
client->internal->running = running;
client->internal->running_context = context;
silc_fsm_init(&client->internal->fsm, client, NULL, NULL, client->schedule);
silc_fsm_event_init(&client->internal->wait_event, &client->internal->fsm);
silc_fsm_start_sync(&client->internal->fsm, silc_client_st_run);
/* Signal the application when we are running */
client->internal->run_callback = TRUE;
SILC_FSM_EVENT_SIGNAL(&client->internal->wait_event);
return TRUE;
}
int main(int argc, char **argv)
{
SilcBool success = FALSE;
SilcMessagePayload message;
SilcBuffer buf;
const char *msg = "FOOBAR MESSAGE";
unsigned char *data, tmp[1023], *tmp2;
SilcUInt32 data_len;
SilcUInt16 flags;
int i, n;
if (argc > 1 && !strcmp(argv[1], "-d")) {
silc_log_debug(TRUE);
silc_log_debug_hexdump(TRUE);
silc_log_set_debug_string("*message*");
}
silc_cipher_register_default();
silc_hash_register_default();
silc_hmac_register_default();
silc_pkcs_register_default();
SILC_LOG_DEBUG(("Load keypair"));
if (!silc_load_key_pair("pubkey.pub", "privkey.prv", "",
&public_key, &private_key)) {
SILC_LOG_DEBUG(("Create keypair"));
if (!silc_create_key_pair("rsa", 2048, "pubkey.pub", "privkey.prv",
NULL, "", &public_key, &private_key, FALSE))
goto err;
}
SILC_LOG_DEBUG(("Alloc RNG"));
rng = silc_rng_alloc();
silc_rng_init(rng);
SILC_LOG_DEBUG(("Alloc AES"));
if (!silc_cipher_alloc("aes-128-cbc", &key))
goto err;
SILC_LOG_DEBUG(("Alloc SHA-256"));
if (!silc_hash_alloc("sha256", &hash))
goto err;
SILC_LOG_DEBUG(("Alloc HMAC"));
if (!silc_hmac_alloc("hmac-sha256-96", hash, &hmac))
goto err;
SILC_LOG_DEBUG(("Set static key: '1234567890123456'"));
if (!silc_cipher_set_key(key, "1234567890123456", 16 * 8))
goto err;
SILC_LOG_DEBUG(("Set HMAC key: '1234567890123456'"));
silc_hmac_set_key(hmac, "1234567890123456", 16);
/* Simple private message */
SILC_LOG_DEBUG(("Encoding private message len %d (static key)",
strlen(msg)));
buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
SILC_MESSAGE_FLAG_UTF8 |
SILC_MESSAGE_FLAG_ACK,
msg, strlen(msg), TRUE, TRUE,
key, hmac, rng, NULL, NULL, NULL, NULL);
if (!buf)
goto err;
SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
SILC_LOG_DEBUG(("Parsing private messsage (static key)"));
message = silc_message_payload_parse(silc_buffer_data(buf),
silc_buffer_len(buf), TRUE, TRUE,
key, hmac, NULL, FALSE, NULL);
if (!message)
goto err;
flags = silc_message_get_flags(message);
SILC_LOG_DEBUG(("Flags: %x", flags));
if (!(flags & SILC_MESSAGE_FLAG_ACTION))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_UTF8))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_ACK))
goto err;
data = silc_message_get_data(message, &data_len);
SILC_LOG_HEXDUMP(("Data"), data, data_len);
if (data_len != strlen(msg) || memcmp(data, msg, strlen(msg)))
goto err;
SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
silc_hmac_len(hmac));
silc_message_payload_free(message);
/* Simple private message */
n = 10;
SILC_LOG_DEBUG(("Encoding private message len %d (static key)", n));
buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
SILC_MESSAGE_FLAG_UTF8 |
SILC_MESSAGE_FLAG_ACK,
msg, n, TRUE, TRUE,
key, hmac, rng, NULL, NULL, NULL, buf);
if (!buf)
goto err;
SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
SILC_LOG_DEBUG(("Parsing private messsage (static key)"));
message = silc_message_payload_parse(silc_buffer_data(buf),
silc_buffer_len(buf), TRUE, TRUE,
key, hmac, NULL, FALSE, NULL);
if (!message)
goto err;
flags = silc_message_get_flags(message);
SILC_LOG_DEBUG(("Flags: %x", flags));
if (!(flags & SILC_MESSAGE_FLAG_ACTION))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_UTF8))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_ACK))
goto err;
data = silc_message_get_data(message, &data_len);
SILC_LOG_HEXDUMP(("Data"), data, data_len);
if (data_len != n || memcmp(data, msg, n))
goto err;
SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
silc_hmac_len(hmac));
silc_message_payload_free(message);
/* Simple private message */
n = 1;
SILC_LOG_DEBUG(("Encoding private message len %d (static key)", n));
buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
SILC_MESSAGE_FLAG_UTF8 |
SILC_MESSAGE_FLAG_ACK,
msg, n, TRUE, TRUE,
key, hmac, rng, NULL, NULL, NULL, buf);
if (!buf)
goto err;
SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
SILC_LOG_DEBUG(("Parsing private messsage (static key)"));
message = silc_message_payload_parse(silc_buffer_data(buf),
silc_buffer_len(buf), TRUE, TRUE,
key, hmac, NULL, FALSE, NULL);
if (!message)
goto err;
flags = silc_message_get_flags(message);
SILC_LOG_DEBUG(("Flags: %x", flags));
if (!(flags & SILC_MESSAGE_FLAG_ACTION))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_UTF8))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_ACK))
goto err;
data = silc_message_get_data(message, &data_len);
SILC_LOG_HEXDUMP(("Data"), data, data_len);
if (data_len != n || memcmp(data, msg, n))
goto err;
SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
silc_hmac_len(hmac));
silc_message_payload_free(message);
/* Simple private message */
for (i = 0; i < sizeof(tmp); i++)
tmp[i] = (32 + i) & 127;
SILC_LOG_DEBUG(("Encoding private message len %d (static key)",
sizeof(tmp)));
buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
SILC_MESSAGE_FLAG_UTF8 |
SILC_MESSAGE_FLAG_ACK,
tmp, sizeof(tmp), TRUE, TRUE,
key, hmac, rng, NULL, NULL, NULL, buf);
if (!buf)
goto err;
SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
SILC_LOG_DEBUG(("Parsing private messsage (static key)"));
message = silc_message_payload_parse(silc_buffer_data(buf),
silc_buffer_len(buf), TRUE, TRUE,
key, hmac, NULL, FALSE, NULL);
if (!message)
goto err;
flags = silc_message_get_flags(message);
SILC_LOG_DEBUG(("Flags: %x", flags));
if (!(flags & SILC_MESSAGE_FLAG_ACTION))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_UTF8))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_ACK))
goto err;
data = silc_message_get_data(message, &data_len);
SILC_LOG_HEXDUMP(("Data"), data, data_len);
if (data_len != sizeof(tmp) || memcmp(data, tmp, sizeof(tmp)))
goto err;
SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
silc_hmac_len(hmac));
silc_message_payload_free(message);
/* Digitally signed private message */
for (i = 0; i < sizeof(tmp); i++)
tmp[i] = (32 + i) & 127;
SILC_LOG_DEBUG(("Encoding private message len %d (static key) SIGNED",
sizeof(tmp)));
buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
SILC_MESSAGE_FLAG_UTF8 |
SILC_MESSAGE_FLAG_ACK |
SILC_MESSAGE_FLAG_SIGNED,
tmp, sizeof(tmp), TRUE, TRUE,
key, hmac, rng,
public_key, private_key, hash, buf);
if (!buf)
goto err;
SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
SILC_LOG_DEBUG(("Parsing private messsage (static key)"));
message = silc_message_payload_parse(silc_buffer_data(buf),
silc_buffer_len(buf), TRUE, TRUE,
key, hmac, NULL, FALSE, NULL);
if (!message)
goto err;
flags = silc_message_get_flags(message);
SILC_LOG_DEBUG(("Flags: %x", flags));
if (!(flags & SILC_MESSAGE_FLAG_ACTION))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_UTF8))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_ACK))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
goto err;
data = silc_message_get_data(message, &data_len);
SILC_LOG_HEXDUMP(("Data"), data, data_len);
if (data_len != sizeof(tmp) || memcmp(data, tmp, sizeof(tmp)))
goto err;
SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
silc_hmac_len(hmac));
SILC_LOG_DEBUG(("Verifying signature"));
if (silc_message_signed_verify(message, public_key, hash) !=
SILC_AUTH_OK)
goto err;
SILC_LOG_DEBUG(("Signature Ok"));
SILC_LOG_DEBUG(("Get public key"));
pk2 = silc_message_signed_get_public_key(message, NULL, NULL);
if (!pk2)
goto err;
SILC_LOG_DEBUG(("Verify public key"));
if (!silc_pkcs_public_key_compare(public_key, pk2))
goto err;
SILC_LOG_DEBUG(("Public key Ok"));
silc_pkcs_public_key_free(pk2);
silc_message_payload_free(message);
/* Digitally signed channel message */
for (i = 0; i < sizeof(tmp) / 2; i++)
tmp[i] = (32 + i) & 127;
SILC_LOG_DEBUG(("Encoding channel message len %d (static key) SIGNED",
sizeof(tmp) / 2));
buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
SILC_MESSAGE_FLAG_UTF8 |
SILC_MESSAGE_FLAG_ACK |
SILC_MESSAGE_FLAG_SIGNED,
tmp, sizeof(tmp) / 2, TRUE, FALSE,
key, hmac, rng,
public_key, private_key, hash, buf);
if (!buf)
goto err;
SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
SILC_LOG_DEBUG(("Parsing channel messsage (static key)"));
message = silc_message_payload_parse(silc_buffer_data(buf),
silc_buffer_len(buf), FALSE, TRUE,
key, hmac, NULL, FALSE, NULL);
if (!message)
goto err;
flags = silc_message_get_flags(message);
SILC_LOG_DEBUG(("Flags: %x", flags));
if (!(flags & SILC_MESSAGE_FLAG_ACTION))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_UTF8))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_ACK))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
goto err;
data = silc_message_get_data(message, &data_len);
SILC_LOG_HEXDUMP(("Data"), data, data_len);
if (data_len != sizeof(tmp) / 2 || memcmp(data, tmp, sizeof(tmp) / 2))
goto err;
SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
silc_hmac_len(hmac));
SILC_LOG_DEBUG(("Verifying signature"));
if (silc_message_signed_verify(message, public_key, hash) !=
SILC_AUTH_OK)
goto err;
SILC_LOG_DEBUG(("Signature Ok"));
SILC_LOG_DEBUG(("Get public key"));
pk2 = silc_message_signed_get_public_key(message, NULL, NULL);
if (!pk2)
goto err;
SILC_LOG_DEBUG(("Verify public key"));
if (!silc_pkcs_public_key_compare(public_key, pk2))
goto err;
SILC_LOG_DEBUG(("Public key Ok"));
silc_pkcs_public_key_free(pk2);
silc_message_payload_free(message);
/* Digitally signed private message (no encryption) */
for (i = 0; i < sizeof(tmp) / 2; i++)
tmp[i] = (32 + i) & 127;
SILC_LOG_DEBUG(("Encoding private message len %d SIGNED",
sizeof(tmp) / 2));
buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
SILC_MESSAGE_FLAG_UTF8 |
SILC_MESSAGE_FLAG_ACK |
SILC_MESSAGE_FLAG_SIGNED,
tmp, sizeof(tmp) / 2, FALSE, TRUE,
NULL, NULL, rng,
public_key, private_key, hash, buf);
if (!buf)
goto err;
SILC_LOG_HEXDUMP(("message"), buf->data, silc_buffer_len(buf));
SILC_LOG_DEBUG(("Parsing private messsage (static key)"));
message = silc_message_payload_parse(silc_buffer_data(buf),
silc_buffer_len(buf), TRUE, FALSE,
NULL, NULL, NULL, FALSE, NULL);
if (!message)
goto err;
flags = silc_message_get_flags(message);
SILC_LOG_DEBUG(("Flags: %x", flags));
if (!(flags & SILC_MESSAGE_FLAG_ACTION))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_UTF8))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_ACK))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
goto err;
data = silc_message_get_data(message, &data_len);
SILC_LOG_HEXDUMP(("Data"), data, data_len);
if (data_len != sizeof(tmp) / 2 || memcmp(data, tmp, sizeof(tmp) / 2))
goto err;
SILC_LOG_DEBUG(("Verifying signature"));
if (silc_message_signed_verify(message, public_key, hash) !=
SILC_AUTH_OK)
goto err;
SILC_LOG_DEBUG(("Signature Ok"));
SILC_LOG_DEBUG(("Get public key"));
pk2 = silc_message_signed_get_public_key(message, NULL, NULL);
if (!pk2)
goto err;
SILC_LOG_DEBUG(("Verify public key"));
if (!silc_pkcs_public_key_compare(public_key, pk2))
goto err;
SILC_LOG_DEBUG(("Public key Ok"));
silc_pkcs_public_key_free(pk2);
silc_message_payload_free(message);
/* Digitally signed channel message (LARGE) */
n = 65550;
tmp2 = silc_malloc(n);
if (!tmp2)
goto err;
SILC_LOG_DEBUG(("Encoding channel message len %d (static key) SIGNED LARGE",
n));
buf = silc_message_payload_encode(SILC_MESSAGE_FLAG_ACTION |
SILC_MESSAGE_FLAG_UTF8 |
SILC_MESSAGE_FLAG_ACK |
SILC_MESSAGE_FLAG_SIGNED,
tmp2, n, TRUE, FALSE,
key, hmac, rng,
public_key, private_key, hash, buf);
if (!buf)
goto err;
SILC_LOG_DEBUG(("Message length: %d", silc_buffer_len(buf)));
if (silc_buffer_len(buf) > SILC_PACKET_MAX_LEN)
goto err;
SILC_LOG_DEBUG(("Parsing channel messsage (static key)"));
message = silc_message_payload_parse(silc_buffer_data(buf),
silc_buffer_len(buf), FALSE, TRUE,
key, hmac, NULL, FALSE, NULL);
if (!message)
goto err;
flags = silc_message_get_flags(message);
SILC_LOG_DEBUG(("Flags: %x", flags));
if (!(flags & SILC_MESSAGE_FLAG_ACTION))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_UTF8))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_ACK))
goto err;
if (!(flags & SILC_MESSAGE_FLAG_SIGNED))
goto err;
data = silc_message_get_data(message, &data_len);
SILC_LOG_DEBUG(("Data len: %d", data_len));
if (silc_buffer_len(buf) > SILC_PACKET_MAX_LEN)
goto err;
SILC_LOG_HEXDUMP(("MAC"), silc_message_get_mac(message),
silc_hmac_len(hmac));
SILC_LOG_DEBUG(("Verifying signature"));
if (silc_message_signed_verify(message, public_key, hash) !=
SILC_AUTH_OK)
goto err;
SILC_LOG_DEBUG(("Signature Ok"));
SILC_LOG_DEBUG(("Get public key"));
pk2 = silc_message_signed_get_public_key(message, NULL, NULL);
if (!pk2)
goto err;
SILC_LOG_DEBUG(("Verify public key"));
if (!silc_pkcs_public_key_compare(public_key, pk2))
goto err;
SILC_LOG_DEBUG(("Public key Ok"));
silc_pkcs_public_key_free(pk2);
silc_message_payload_free(message);
silc_free(tmp2);
success = TRUE;
SILC_LOG_DEBUG(("Cleanup"));
silc_pkcs_public_key_free(public_key);
silc_pkcs_private_key_free(private_key);
silc_cipher_free(key);
silc_hash_free(hash);
silc_rng_free(rng);
err:
silc_cipher_unregister_all();
silc_hash_unregister_all();
silc_hmac_unregister_all();
silc_pkcs_unregister_all();
SILC_LOG_DEBUG(("Testing was %s", success ? "SUCCESS" : "FAILURE"));
fprintf(stderr, "Testing was %s\n", success ? "SUCCESS" : "FAILURE");
return success;
}
