SilcBool silc_public_key_payload_decode(unsigned char *data,
SilcUInt32 data_len,
SilcPublicKey *public_key)
{
SilcBufferStruct buf;
SilcUInt16 pk_len, pk_type;
unsigned char *pk;
int ret;
if (!public_key)
return FALSE;
silc_buffer_set(&buf, data, data_len);
ret = silc_buffer_unformat(&buf,
SILC_STR_ADVANCE,
SILC_STR_UI_SHORT(&pk_len),
SILC_STR_UI_SHORT(&pk_type),
SILC_STR_END);
if (ret < 0 || pk_len > data_len - 4)
return FALSE;
if (pk_type < SILC_PKCS_SILC || pk_type > SILC_PKCS_SPKI)
return FALSE;
ret = silc_buffer_unformat(&buf,
SILC_STR_DATA(&pk, pk_len),
SILC_STR_END);
if (ret < 0)
return FALSE;
return silc_pkcs_public_key_alloc((SilcPKCSType)pk_type,
pk, pk_len, public_key);
}
static void
silcpurple_wb_parse(SilcPurpleWb wbs, PurpleWhiteboard *wb,
unsigned char *message, SilcUInt32 message_len)
{
SilcUInt8 command;
SilcUInt16 width, height, brush_size;
SilcUInt32 brush_color, x, y, dx, dy;
SilcBufferStruct buf;
int ret;
/* Parse the packet */
silc_buffer_set(&buf, message, message_len);
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_CHAR(&command),
SILC_STR_UI_SHORT(&width),
SILC_STR_UI_SHORT(&height),
SILC_STR_UI_INT(&brush_color),
SILC_STR_UI_SHORT(&brush_size),
SILC_STR_END);
if (ret < 0)
return;
silc_buffer_pull(&buf, ret);
/* Update whiteboard if its dimensions changed */
if (width != wbs->width || height != wbs->height)
silcpurple_wb_set_dimensions(wb, height, width);
if (command == SILCPURPLE_WB_DRAW) {
/* Parse data and draw it */
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&dx),
SILC_STR_UI_INT(&dy),
SILC_STR_END);
if (ret < 0)
return;
silc_buffer_pull(&buf, 8);
x = dx;
y = dy;
while (silc_buffer_len(&buf) > 0) {
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&dx),
SILC_STR_UI_INT(&dy),
SILC_STR_END);
if (ret < 0)
return;
silc_buffer_pull(&buf, 8);
purple_whiteboard_draw_line(wb, x, y, x + dx, y + dy,
brush_color, brush_size);
x += dx;
y += dy;
}
}
if (command == SILCPURPLE_WB_CLEAR)
purple_whiteboard_clear(wb);
}
SilcCommandPayload silc_command_payload_parse(const unsigned char *payload,
SilcUInt32 payload_len)
{
SilcBufferStruct buffer;
SilcCommandPayload newp;
unsigned char args_num;
SilcUInt16 p_len;
int ret;
SILC_LOG_DEBUG(("Parsing command payload"));
silc_buffer_set(&buffer, (unsigned char *)payload, payload_len);
newp = silc_calloc(1, sizeof(*newp));
if (!newp)
return NULL;
/* Parse the Command Payload */
ret = silc_buffer_unformat(&buffer,
SILC_STR_UI_SHORT(&p_len),
SILC_STR_UI_CHAR(&newp->cmd),
SILC_STR_UI_CHAR(&args_num),
SILC_STR_UI_SHORT(&newp->ident),
SILC_STR_END);
if (ret == -1) {
SILC_LOG_ERROR(("Incorrect command payload in packet"));
silc_free(newp);
return NULL;
}
if (p_len != silc_buffer_len(&buffer)) {
SILC_LOG_ERROR(("Incorrect command payload in packet"));
silc_free(newp);
return NULL;
}
if (newp->cmd == 0) {
SILC_LOG_ERROR(("Incorrect command type in command payload"));
silc_free(newp);
return NULL;
}
silc_buffer_pull(&buffer, SILC_COMMAND_PAYLOAD_LEN);
if (args_num) {
newp->args = silc_argument_payload_parse(buffer.data,
silc_buffer_len(&buffer),
args_num);
if (!newp->args) {
silc_free(newp);
return NULL;
}
}
silc_buffer_push(&buffer, SILC_COMMAND_PAYLOAD_LEN);
return newp;
}
int silc_pkcs1_import_private_key(unsigned char *key,
SilcUInt32 key_len,
void **ret_private_key)
{
SilcAsn1 asn1;
SilcBufferStruct alg_key;
RsaPrivateKey *privkey;
SilcUInt32 ver;
if (!ret_private_key)
return 0;
asn1 = silc_asn1_alloc();
if (!asn1)
return 0;
/* Allocate RSA private key */
*ret_private_key = privkey = silc_calloc(1, sizeof(*privkey));
if (!privkey)
goto err;
/* Parse the PKCS #1 private key */
silc_buffer_set(&alg_key, key, key_len);
if (!silc_asn1_decode(asn1, &alg_key,
SILC_ASN1_OPTS(SILC_ASN1_ALLOC),
SILC_ASN1_SEQUENCE,
SILC_ASN1_SHORT_INT(&ver),
SILC_ASN1_INT(&privkey->n),
SILC_ASN1_INT(&privkey->e),
SILC_ASN1_INT(&privkey->d),
SILC_ASN1_INT(&privkey->p),
SILC_ASN1_INT(&privkey->q),
SILC_ASN1_INT(&privkey->dP),
SILC_ASN1_INT(&privkey->dQ),
SILC_ASN1_INT(&privkey->qP),
SILC_ASN1_END, SILC_ASN1_END))
goto err;
if (ver != 0)
goto err;
/* Set key length */
privkey->bits = ((silc_mp_sizeinbase(&privkey->n, 2) + 7) / 8) * 8;
silc_asn1_free(asn1);
return key_len;
err:
silc_free(privkey);
silc_asn1_free(asn1);
return 0;
}
unsigned char *silc_attribute_get_verify_data(SilcDList attrs,
SilcBool server_verification,
SilcUInt32 *data_len)
{
SilcAttributePayload attr;
SilcBufferStruct buffer;
unsigned char *data = NULL;
SilcUInt32 len = 0;
silc_dlist_start(attrs);
while ((attr = silc_dlist_get(attrs)) != SILC_LIST_END) {
switch (attr->attribute) {
case SILC_ATTRIBUTE_SERVER_DIGITAL_SIGNATURE:
/* Server signature is never part of the verification data */
break;
case SILC_ATTRIBUTE_USER_DIGITAL_SIGNATURE:
/* For user signature verification this is not part of the data */
if (!server_verification)
break;
/* Fallback, for server signature verification, user digital signature
is part of verification data. */
default:
/* All other data is part of the verification data */
data = silc_realloc(data, sizeof(*data) * (4 + attr->data_len + len));
if (!data)
return NULL;
silc_buffer_set(&buffer, data + len, 4 + attr->data_len);
silc_buffer_format(&buffer,
SILC_STR_UI_CHAR(attr->attribute),
SILC_STR_UI_CHAR(attr->flags),
SILC_STR_UI_SHORT(attr->data_len),
SILC_STR_UI_XNSTRING(attr->data, attr->data_len),
SILC_STR_END);
len += 4 + attr->data_len;
break;
}
}
if (data_len)
*data_len = len;
return data;
}
SilcDList silc_attribute_payload_parse(const unsigned char *payload,
SilcUInt32 payload_len)
{
SilcBufferStruct buffer;
SilcDList list;
SilcAttributePayload newp;
SilcUInt32 len;
int ret;
SILC_LOG_DEBUG(("Parsing Attribute Payload list"));
silc_buffer_set(&buffer, (unsigned char *)payload, payload_len);
list = silc_dlist_init();
while (silc_buffer_len(&buffer)) {
newp = silc_calloc(1, sizeof(*newp));
if (!newp)
goto err;
ret = silc_buffer_unformat(&buffer,
SILC_STR_UI_CHAR(&newp->attribute),
SILC_STR_UI_CHAR(&newp->flags),
SILC_STR_UI16_NSTRING_ALLOC(&newp->data,
&newp->data_len),
SILC_STR_END);
if (ret == -1)
goto err;
if (newp->data_len > silc_buffer_len(&buffer) - 4) {
SILC_LOG_ERROR(("Incorrect attribute payload in list"));
goto err;
}
len = 4 + newp->data_len;
if (silc_buffer_len(&buffer) < len)
break;
silc_buffer_pull(&buffer, len);
silc_dlist_add(list, newp);
}
return list;
err:
silc_attribute_payload_list_free(list);
return NULL;
}
SilcNotifyPayload silc_notify_payload_parse(const unsigned char *payload,
SilcUInt32 payload_len)
{
SilcBufferStruct buffer;
SilcNotifyPayload newp;
SilcUInt16 len;
int ret;
SILC_LOG_DEBUG(("Parsing Notify payload"));
silc_buffer_set(&buffer, (unsigned char *)payload, payload_len);
newp = silc_calloc(1, sizeof(*newp));
if (!newp)
return NULL;
ret = silc_buffer_unformat(&buffer,
SILC_STR_UI_SHORT(&newp->type),
SILC_STR_UI_SHORT(&len),
SILC_STR_UI_CHAR(&newp->argc),
SILC_STR_END);
if (ret == -1)
goto err;
if (len > silc_buffer_len(&buffer))
goto err;
if (newp->argc) {
silc_buffer_pull(&buffer, 5);
newp->args = silc_argument_payload_parse(buffer.data,
silc_buffer_len(&buffer),
newp->argc);
if (!newp->args)
goto err;
silc_buffer_push(&buffer, 5);
}
return newp;
err:
silc_free(newp);
return NULL;
}
int silc_pkcs1_import_public_key(unsigned char *key,
SilcUInt32 key_len,
void **ret_public_key)
{
SilcAsn1 asn1 = NULL;
SilcBufferStruct alg_key;
RsaPublicKey *pubkey;
if (!ret_public_key)
return 0;
asn1 = silc_asn1_alloc();
if (!asn1)
return 0;
/* Allocate RSA public key */
*ret_public_key = pubkey = silc_calloc(1, sizeof(*pubkey));
if (!pubkey)
goto err;
/* Parse the PKCS #1 public key */
silc_buffer_set(&alg_key, key, key_len);
if (!silc_asn1_decode(asn1, &alg_key,
SILC_ASN1_OPTS(SILC_ASN1_ALLOC),
SILC_ASN1_SEQUENCE,
SILC_ASN1_INT(&pubkey->n),
SILC_ASN1_INT(&pubkey->e),
SILC_ASN1_END, SILC_ASN1_END))
goto err;
/* Set key length */
pubkey->bits = ((silc_mp_sizeinbase(&pubkey->n, 2) + 7) / 8) * 8;
silc_asn1_free(asn1);
return key_len;
err:
silc_free(pubkey);
silc_asn1_free(asn1);
return 0;
}
SilcBool silc_attribute_get_object(SilcAttributePayload payload,
void *object, SilcUInt32 object_size)
{
SilcUInt16 len;
SilcBool ret = FALSE;
if (!object || payload->flags & SILC_ATTRIBUTE_FLAG_INVALID)
return FALSE;
switch (payload->attribute) {
case SILC_ATTRIBUTE_USER_INFO:
{
SilcVCard vcard = object;
if (object_size != sizeof(*vcard))
break;
if (!silc_vcard_decode(payload->data, payload->data_len, vcard))
break;
ret = TRUE;
}
break;
case SILC_ATTRIBUTE_SERVICE:
{
SilcAttributeObjService *service = object;
SilcBufferStruct buf;
SilcUInt16 addr_len, signon_len;
char *addr, *signon;
int res;
if (object_size != sizeof(*service))
break;
if (payload->data_len < 13)
break;
silc_buffer_set(&buf, payload->data, payload->data_len);
res = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&service->port),
SILC_STR_UI16_NSTRING(&addr, &addr_len),
SILC_STR_UI_CHAR(&service->status),
SILC_STR_UI16_NSTRING(&signon, &signon_len),
SILC_STR_UI_INT(&service->idle),
SILC_STR_END);
if (res == -1)
break;
memset(service->address, 0, sizeof(service->address));
memset(service->signon, 0, sizeof(service->signon));
memcpy(service->address, addr,
(addr_len < sizeof(service->address) - 1 ? addr_len :
sizeof(service->address) - 1));
memcpy(service->signon, signon,
(signon_len < sizeof(service->signon) - 1 ? signon_len :
sizeof(service->signon) - 1));
ret = TRUE;
}
break;
case SILC_ATTRIBUTE_STATUS_MOOD:
case SILC_ATTRIBUTE_PREFERRED_CONTACT:
{
SilcUInt32 *mask = (SilcUInt32 *)object;
if (object_size != sizeof(SilcUInt32))
break;
if (payload->data_len < 4)
break;
SILC_GET32_MSB(*mask, payload->data);
ret = TRUE;
}
break;
case SILC_ATTRIBUTE_STATUS_FREETEXT:
case SILC_ATTRIBUTE_PREFERRED_LANGUAGE:
case SILC_ATTRIBUTE_TIMEZONE:
{
char *string = object;
if (payload->data_len < 2)
break;
SILC_GET16_MSB(len, payload->data);
if (payload->data_len < 2 + len)
break;
if (object_size < len)
break;
memcpy(string, payload->data + 2, len);
ret = TRUE;
}
break;
case SILC_ATTRIBUTE_STATUS_MESSAGE:
case SILC_ATTRIBUTE_EXTENSION:
case SILC_ATTRIBUTE_USER_ICON:
{
SilcMime mime = object;
if (object_size != sizeof(*mime))
break;
if (!silc_mime_decode(mime, payload->data, payload->data_len))
break;
ret = TRUE;
}
break;
case SILC_ATTRIBUTE_GEOLOCATION:
{
SilcAttributeObjGeo *geo = object;
SilcBufferStruct buffer;
int res;
if (object_size != sizeof(*geo))
break;
silc_buffer_set(&buffer, (unsigned char *)payload->data,
payload->data_len);
res = silc_buffer_unformat(&buffer,
SILC_STR_UI16_STRING_ALLOC(&geo->longitude),
SILC_STR_UI16_STRING_ALLOC(&geo->latitude),
SILC_STR_UI16_STRING_ALLOC(&geo->altitude),
SILC_STR_UI16_STRING_ALLOC(&geo->accuracy),
SILC_STR_END);
if (res == -1)
break;
ret = TRUE;
}
break;
case SILC_ATTRIBUTE_DEVICE_INFO:
{
SilcAttributeObjDevice *dev = object;
SilcBufferStruct buffer;
SilcUInt32 type;
int res;
if (object_size != sizeof(*dev))
break;
silc_buffer_set(&buffer, (unsigned char *)payload->data,
payload->data_len);
res =
silc_buffer_unformat(&buffer,
SILC_STR_UI_INT(&type),
SILC_STR_UI16_STRING_ALLOC(&dev->manufacturer),
SILC_STR_UI16_STRING_ALLOC(&dev->version),
SILC_STR_UI16_STRING_ALLOC(&dev->model),
SILC_STR_UI16_STRING_ALLOC(&dev->language),
SILC_STR_END);
if (res == -1)
break;
dev->type = type;
ret = TRUE;
}
break;
case SILC_ATTRIBUTE_PHONE_NUMBER:
{
SilcAttributeObjPN *pn = object;
SilcBufferStruct buffer;
SilcUInt32 pn_format;
int res;
if (object_size != sizeof(*pn))
break;
silc_buffer_set(&buffer, (unsigned char *)payload->data,
payload->data_len);
res =
silc_buffer_unformat(&buffer,
SILC_STR_UI_INT(&pn_format),
SILC_STR_UI16_STRING_ALLOC(&pn->number),
SILC_STR_END);
if (res == -1)
break;
pn->format = pn_format;
ret = TRUE;
}
break;
case SILC_ATTRIBUTE_USER_PUBLIC_KEY:
case SILC_ATTRIBUTE_SERVER_PUBLIC_KEY:
{
SilcAttributeObjPk *pk = object;
SilcBufferStruct buffer;
int res;
if (object_size != sizeof(*pk))
break;
silc_buffer_set(&buffer, (unsigned char *)payload->data,
payload->data_len);
res =
silc_buffer_unformat(&buffer,
SILC_STR_UI16_NSTRING_ALLOC(&pk->type, &len),
SILC_STR_END);
if (res == -1 || len > silc_buffer_len(&buffer) - 2)
break;
pk->data = silc_memdup(payload->data + 2 + len,
payload->data_len - 2 - len);
pk->data_len = payload->data_len - 2 - len;
ret = TRUE;
}
break;
case SILC_ATTRIBUTE_USER_DIGITAL_SIGNATURE:
case SILC_ATTRIBUTE_SERVER_DIGITAL_SIGNATURE:
{
SilcAttributeObjPk *pk = object;
if (object_size != sizeof(*pk))
break;
pk->type = NULL;
pk->data = silc_memdup(payload->data, payload->data_len);
pk->data_len = payload->data_len;
ret = TRUE;
}
break;
default:
break;
}
return ret;
}
int main(int argc, char **argv)
{
int opt, ret, i;
SilcAsn1 asn1;
SilcBufferStruct buf;
unsigned char *data, *tmp;
SilcUInt32 data_len;
if (argc < 2) {
usage();
return 1;
}
while ((opt = getopt(argc, argv, "hxbai")) != EOF) {
switch (opt) {
case 'h':
usage();
return 1;
break;
case 'x':
hexdump = TRUE;
break;
case 'b':
dec_base64 = TRUE;
break;
case 'i':
ignore_header = TRUE;
break;
case 'a':
parse_all = TRUE;
break;
default:
usage();
return 1;
}
}
data = tmp = silc_file_readfile(argv[argc - 1], &data_len, NULL);
if (!data) {
fprintf(stderr, "Error: Cannot read file '%s': %s\n", argv[argc - 1],
silc_errno_string(silc_errno));
return 1;
}
silc_buffer_set(&buf, data, data_len);
if (ignore_header) {
SilcBool header = FALSE;
for (i = 0; i < data_len; i++) {
if (data_len > i + 4 &&
data[i ] == '-' && data[i + 1] == '-' &&
data[i + 2] == '-' && data[i + 3] == '-') {
if (data_len > i + 5 && (data[i + 4] == '\r' ||
tmp[i + 4] == '\n')) {
/* End of line, header */
if (data_len > i + 6 && data[i + 4] == '\r' &&
data[i + 5] == '\n')
i++;
i += 5;
silc_buffer_pull(&buf, i);
header = TRUE;
} else if (i > 0 && data_len > i + 5 && data[i + 4] != '-' &&
header) {
/* Start of line, footer */
silc_buffer_push_tail(&buf, silc_buffer_truelen(&buf) - i);
break;
}
}
}
}
if (dec_base64) {
data = silc_base64_decode(NULL, silc_buffer_data(&buf),
silc_buffer_len(&buf), &data_len);
if (!data) {
fprintf(stderr, "Error: Cannot decode Base64 encoding\n");
return 1;
}
silc_buffer_set(&buf, data, data_len);
silc_free(tmp);
}
asn1 = silc_asn1_alloc(NULL);
ret = asn1_dump(asn1, &buf, 0);
silc_asn1_free(asn1);
silc_free(data);
return ret;
}
int asn1_dump(SilcAsn1 asn1, SilcBuffer src, int depth)
{
SilcBool ret = FALSE;
SilcBerEncoding renc;
SilcUInt32 rtag;
const unsigned char *rdata;
SilcBufferStruct buf;
SilcBerClass rclass;
SilcUInt32 rdata_len, len = 0;
SilcBool rindef;
char indent[256];
memset(indent, 0, sizeof(indent));
while (silc_buffer_len(src)) {
/* Decode the BER block */
ret = silc_ber_decode(src, &rclass, &renc, &rtag, &rdata,
&rdata_len, &rindef, &len);
if (!ret) {
fprintf(stderr, "Error: Cannot parse BER block, malformed ASN.1 data\n");
return -1;
}
/* If class is 0, encoding 0, tag 0 and data length 0 ignore them
as they are zero bytes, unless user wants to see them */
if (rclass == 0 && renc == 0 && rtag == 0 && rdata_len == 0 &&
!parse_all) {
if (len && silc_buffer_len(src) >= len)
silc_buffer_pull(src, len);
continue;
}
if (depth)
memset(indent, 32, depth);
fprintf(stdout, "%04d: %s%s [%d] %s %s %s", depth, indent,
asn1_tag_name(rtag), (int)rtag,
rclass == SILC_BER_CLASS_UNIVERSAL ? "univ" :
rclass == SILC_BER_CLASS_APPLICATION ? "appl" :
rclass == SILC_BER_CLASS_CONTEXT ? "cont" : "priv",
renc == SILC_BER_ENC_PRIMITIVE ? "primit" : "constr",
rindef ? "indef" : "defin");
if (rtag != SILC_ASN1_TAG_SEQUENCE &&
rtag != SILC_ASN1_TAG_SET &&
rtag != SILC_ASN1_TAG_SEQUENCE_OF) {
if (hexdump) {
fprintf(stdout, " [len %lu]\n", rdata_len);
silc_hexdump(rdata, rdata_len, stdout);
} else {
fprintf(stdout, "\n");
}
} else {
fprintf(stdout, "\n");
}
if (renc == SILC_BER_ENC_PRIMITIVE)
len = len + rdata_len;
else
len = len;
if (len && silc_buffer_len(src) >= len)
silc_buffer_pull(src, len);
/* Decode sequences and sets recursively */
if ((rtag == SILC_ASN1_TAG_SEQUENCE ||
rtag == SILC_ASN1_TAG_SET ||
rtag == SILC_ASN1_TAG_SEQUENCE_OF) &&
depth + 1 < sizeof(indent) - 1) {
silc_buffer_set(&buf, (unsigned char *)rdata, rdata_len);
if (silc_buffer_len(src) >= rdata_len)
silc_buffer_pull(src, rdata_len);
if (asn1_dump(asn1, &buf, depth + 1) < 0)
return -1;
if (silc_buffer_len(src) == 0)
return 0;
}
}
return 0;
}
static void silc_pkcs_ssh_sign_cb(SilcBool success,
const unsigned char *signature,
SilcUInt32 signature_len,
void *context)
{
SilcSshSign sign = context;
SilcStack stack = sign->stack;
unsigned char rbuf[20], sbuf[20];
SilcBufferStruct sig;
SilcAsn1 asn1;
SilcMPInt r, s;
memset(&sig, 0, sizeof(sig));
/* Format the signature. RSA is easy because PKCS#1 is already in
correct format. For DSA the returned signature is in PKIX compliant
format and we have to reformat it for SSH2. */
if (!strcmp(sign->privkey->pkcs->name, "dsa")) {
asn1 = silc_asn1_alloc(stack);
if (!asn1) {
sign->sign_cb(FALSE, NULL, 0, sign->context);
silc_sfree(stack, sign);
silc_stack_free(stack);
return;
}
/* Decode the signature */
silc_buffer_set(&sig, (unsigned char *)signature, signature_len);
if (!silc_asn1_decode(asn1, &sig,
SILC_ASN1_SEQUENCE,
SILC_ASN1_INT(&r),
SILC_ASN1_INT(&s),
SILC_ASN1_END, SILC_ASN1_END)) {
sign->sign_cb(FALSE, NULL, 0, sign->context);
silc_asn1_free(asn1);
silc_sfree(stack, sign);
silc_stack_free(stack);
return;
}
/* Encode the integers */
memset(rbuf, 0, sizeof(rbuf));
memset(sbuf, 0, sizeof(sbuf));
silc_mp_mp2bin_noalloc(&r, rbuf, sizeof(rbuf));
silc_mp_mp2bin_noalloc(&s, sbuf, sizeof(sbuf));
silc_asn1_free(asn1);
/* Encode SSH2 DSS signature */
if (silc_buffer_sformat(stack, &sig,
SILC_STR_UI_INT(7),
SILC_STR_UI32_STRING("ssh-dss"),
SILC_STR_UI_INT(sizeof(rbuf) + sizeof(sbuf)),
SILC_STR_DATA(rbuf, sizeof(rbuf)),
SILC_STR_DATA(sbuf, sizeof(sbuf)),
SILC_STR_END) < 0) {
sign->sign_cb(FALSE, NULL, 0, sign->context);
silc_sfree(stack, sign);
silc_stack_free(stack);
return;
}
} else {
/* Encode SSH2 RSA signature */
if (silc_buffer_sformat(stack, &sig,
SILC_STR_UI_INT(7),
SILC_STR_UI32_STRING("ssh-rsa"),
SILC_STR_UI_INT(signature_len),
SILC_STR_DATA(signature, signature_len),
SILC_STR_END) < 0) {
sign->sign_cb(FALSE, NULL, 0, sign->context);
silc_sfree(stack, sign);
silc_stack_free(stack);
return;
}
}
/* Deliver result */
sign->sign_cb(TRUE, silc_buffer_data(&sig), silc_buffer_len(&sig),
sign->context);
silc_buffer_spurge(stack, &sig);
silc_sfree(stack, sign);
silc_stack_free(stack);
}
static void silc_sftp_server_io(SilcStream stream, SilcStreamStatus status,
void *context)
{
SilcSFTPServer sftp = context;
unsigned char inbuf[33792];
SilcBufferStruct packet;
int ret;
switch (status) {
case SILC_STREAM_CAN_READ:
SILC_LOG_DEBUG(("Reading data from stream"));
/* Read data from stream */
ret = silc_stream_read(stream, inbuf, sizeof(inbuf));
if (ret <= 0) {
if (ret == 0)
sftp->error(context, SILC_SFTP_STATUS_EOF, sftp->context);
if (ret == -2)
sftp->error(context, SILC_SFTP_STATUS_NO_CONNECTION, sftp->context);
return;
}
/* Now process the SFTP packet */
silc_buffer_set(&packet, inbuf, ret);
silc_sftp_server_receive_process(context, &packet);
break;
case SILC_STREAM_CAN_WRITE:
if (!silc_buffer_headlen(sftp->packet))
return;
SILC_LOG_DEBUG(("Writing pending data to stream"));
/* Write pending data to stream */
silc_buffer_push(sftp->packet, silc_buffer_headlen(sftp->packet));
while (silc_buffer_len(sftp->packet) > 0) {
ret = silc_stream_write(stream, sftp->packet->data,
silc_buffer_len(sftp->packet));
if (ret == 0) {
sftp->error(context, SILC_SFTP_STATUS_EOF, sftp->context);
silc_buffer_reset(sftp->packet);
return;
}
if (ret == -2) {
sftp->error(context, SILC_SFTP_STATUS_NO_CONNECTION, sftp->context);
silc_buffer_reset(sftp->packet);
return;
}
if (ret == -1)
return;
/* Wrote data */
silc_buffer_pull(sftp->packet, ret);
}
break;
default:
break;
}
}
static void silc_sftp_server_receive_process(SilcSFTP sftp, SilcBuffer buffer)
{
SilcSFTPServer server = (SilcSFTPServer)sftp;
SilcSFTPPacket type;
char *filename = NULL, *path = NULL;
unsigned char *payload = NULL;
SilcUInt32 payload_len;
int ret;
SilcBufferStruct buf;
SilcUInt32 id;
SilcSFTPAttributes attrs;
SilcSFTPHandle handle;
SilcSFTPMonitorDataStruct mdata;
SILC_LOG_DEBUG(("Start"));
/* Parse the packet */
type = silc_sftp_packet_decode(buffer, &payload, &payload_len);
if (type <= 0)
return;
silc_buffer_set(&buf, payload, payload_len);
memset(&mdata, 0, sizeof(mdata));
switch (type) {
case SILC_SFTP_READ:
{
unsigned char *hdata;
SilcUInt32 hdata_len;
SilcUInt64 offset;
SilcUInt32 len;
SILC_LOG_DEBUG(("Read request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_NSTRING(&hdata,
&hdata_len),
SILC_STR_UI_INT64(&offset),
SILC_STR_UI_INT(&len),
SILC_STR_END);
if (ret < 0)
goto failure;
/* Get the handle */
handle = server->fs->fs->sftp_get_handle(server->fs->fs_context, sftp,
(const unsigned char *)hdata,
hdata_len);
if (!handle) {
silc_sftp_send_error(server, SILC_SFTP_STATUS_NO_SUCH_FILE, id);
break;
}
/* Read operation */
server->fs->fs->sftp_read(server->fs->fs_context, sftp,
handle, offset, len,
silc_sftp_server_data, SILC_32_TO_PTR(id));
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_READ && server->monitor) {
mdata.offset = offset;
mdata.data_len = len;
(*server->monitor)(sftp, SILC_SFTP_MONITOR_READ, &mdata,
server->monitor_context);
}
}
break;
case SILC_SFTP_WRITE:
{
unsigned char *hdata;
SilcUInt32 hdata_len;
SilcUInt64 offset;
unsigned char *data;
SilcUInt32 data_len;
SILC_LOG_DEBUG(("Read request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_NSTRING(&hdata,
&hdata_len),
SILC_STR_UI_INT64(&offset),
SILC_STR_UI32_NSTRING(&data,
&data_len),
SILC_STR_END);
if (ret < 0)
goto failure;
/* Get the handle */
handle = server->fs->fs->sftp_get_handle(server->fs->fs_context, sftp,
(const unsigned char *)hdata,
hdata_len);
if (!handle) {
silc_sftp_send_error(server, SILC_SFTP_STATUS_NO_SUCH_FILE, id);
break;
}
/* Write operation */
server->fs->fs->sftp_write(server->fs->fs_context, sftp, handle, offset,
(const unsigned char *)data, data_len,
silc_sftp_server_status, SILC_32_TO_PTR(id));
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_WRITE && server->monitor) {
mdata.offset = offset;
mdata.data_len = data_len;
(*server->monitor)(sftp, SILC_SFTP_MONITOR_WRITE, &mdata,
server->monitor_context);
}
}
break;
case SILC_SFTP_INIT:
{
SilcSFTPVersion version;
SILC_LOG_DEBUG(("Init request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&version),
SILC_STR_END);
if (ret < 0)
break;
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_INIT && server->monitor) {
mdata.version = version;
(*server->monitor)(sftp, SILC_SFTP_MONITOR_INIT, &mdata,
server->monitor_context);
}
silc_sftp_send_packet(server, SILC_SFTP_VERSION, 4,
SILC_STR_UI_INT(SILC_SFTP_PROTOCOL_VERSION),
SILC_STR_END);
}
break;
case SILC_SFTP_OPEN:
{
SilcSFTPFileOperation pflags;
unsigned char *attr_buf;
SilcUInt32 attr_len = 0;
SilcBufferStruct tmpbuf;
SILC_LOG_DEBUG(("Open request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_STRING_ALLOC(&filename),
SILC_STR_UI_INT(&pflags),
SILC_STR_UI32_NSTRING(&attr_buf,
&attr_len),
SILC_STR_END);
if (ret < 0)
goto failure;
if (attr_len) {
silc_buffer_set(&tmpbuf, attr_buf, attr_len);
attrs = silc_sftp_attr_decode(&tmpbuf);
if (!attrs)
goto failure;
} else {
attrs = silc_calloc(1, sizeof(*attrs));
if (!attrs)
goto failure;
}
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_OPEN && server->monitor) {
mdata.name = filename;
mdata.pflags = pflags;
(*server->monitor)(sftp, SILC_SFTP_MONITOR_OPEN, &mdata,
server->monitor_context);
}
/* Open operation */
server->fs->fs->sftp_open(server->fs->fs_context, sftp, filename, pflags,
attrs, silc_sftp_server_handle,
SILC_32_TO_PTR(id));
silc_free(filename);
silc_sftp_attr_free(attrs);
}
break;
case SILC_SFTP_CLOSE:
{
unsigned char *hdata;
SilcUInt32 hdata_len;
SILC_LOG_DEBUG(("Close request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_NSTRING(&hdata,
&hdata_len),
SILC_STR_END);
if (ret < 0)
goto failure;
/* Get the handle */
handle = server->fs->fs->sftp_get_handle(server->fs->fs_context, sftp,
(const unsigned char *)hdata,
hdata_len);
if (!handle) {
silc_sftp_send_error(server, SILC_SFTP_STATUS_NO_SUCH_FILE, id);
break;
}
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_CLOSE && server->monitor) {
(*server->monitor)(sftp, SILC_SFTP_MONITOR_CLOSE, &mdata,
server->monitor_context);
}
/* Close operation */
server->fs->fs->sftp_close(server->fs->fs_context, sftp, handle,
silc_sftp_server_status, SILC_32_TO_PTR(id));
}
break;
case SILC_SFTP_REMOVE:
{
SILC_LOG_DEBUG(("Remove request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_STRING_ALLOC(&filename),
SILC_STR_END);
if (ret < 0)
goto failure;
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_REMOVE && server->monitor) {
mdata.name = filename;
(*server->monitor)(sftp, SILC_SFTP_MONITOR_REMOVE, &mdata,
server->monitor_context);
}
/* Remove operation */
server->fs->fs->sftp_remove(server->fs->fs_context, sftp, filename,
silc_sftp_server_status, SILC_32_TO_PTR(id));
silc_free(filename);
}
break;
case SILC_SFTP_RENAME:
{
char *newname = NULL;
SILC_LOG_DEBUG(("Rename request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_STRING_ALLOC(&filename),
SILC_STR_UI32_STRING_ALLOC(&newname),
SILC_STR_END);
if (ret < 0)
goto failure;
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_RENAME && server->monitor) {
mdata.name = filename;
mdata.name2 = newname;
(*server->monitor)(sftp, SILC_SFTP_MONITOR_RENAME, &mdata,
server->monitor_context);
}
/* Rename operation */
server->fs->fs->sftp_rename(server->fs->fs_context, sftp,
filename, newname,
silc_sftp_server_status, SILC_32_TO_PTR(id));
silc_free(filename);
silc_free(newname);
}
break;
case SILC_SFTP_MKDIR:
{
unsigned char *attr_buf;
SilcUInt32 attr_len = 0;
SilcBufferStruct tmpbuf;
SILC_LOG_DEBUG(("Mkdir request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_STRING_ALLOC(&path),
SILC_STR_UI32_NSTRING(&attr_buf,
&attr_len),
SILC_STR_END);
if (ret < 0)
goto failure;
if (attr_len) {
silc_buffer_set(&tmpbuf, attr_buf, attr_len);
attrs = silc_sftp_attr_decode(&tmpbuf);
if (!attrs)
goto failure;
} else {
attrs = silc_calloc(1, sizeof(*attrs));
if (!attrs)
goto failure;
}
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_MKDIR && server->monitor) {
mdata.name = path;
(*server->monitor)(sftp, SILC_SFTP_MONITOR_MKDIR, &mdata,
server->monitor_context);
}
/* Mkdir operation */
server->fs->fs->sftp_mkdir(server->fs->fs_context, sftp, path, attrs,
silc_sftp_server_status, SILC_32_TO_PTR(id));
silc_sftp_attr_free(attrs);
silc_free(path);
}
break;
case SILC_SFTP_RMDIR:
{
SILC_LOG_DEBUG(("Rmdir request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_STRING_ALLOC(&path),
SILC_STR_END);
if (ret < 0)
goto failure;
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_RMDIR && server->monitor) {
mdata.name = path;
(*server->monitor)(sftp, SILC_SFTP_MONITOR_RMDIR, &mdata,
server->monitor_context);
}
/* Rmdir operation */
server->fs->fs->sftp_rmdir(server->fs->fs_context, sftp, path,
silc_sftp_server_status, SILC_32_TO_PTR(id));
silc_free(path);
}
break;
case SILC_SFTP_OPENDIR:
{
SILC_LOG_DEBUG(("Opendir request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_STRING_ALLOC(&path),
SILC_STR_END);
if (ret < 0)
goto failure;
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_OPENDIR && server->monitor) {
mdata.name = path;
(*server->monitor)(sftp, SILC_SFTP_MONITOR_OPENDIR, &mdata,
server->monitor_context);
}
/* Opendir operation */
server->fs->fs->sftp_opendir(server->fs->fs_context, sftp, path,
silc_sftp_server_handle, SILC_32_TO_PTR(id));
silc_free(path);
}
break;
case SILC_SFTP_READDIR:
{
unsigned char *hdata;
SilcUInt32 hdata_len;
SILC_LOG_DEBUG(("Readdir request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_NSTRING(&hdata,
&hdata_len),
SILC_STR_END);
if (ret < 0)
goto failure;
/* Get the handle */
handle = server->fs->fs->sftp_get_handle(server->fs->fs_context, sftp,
(const unsigned char *)hdata,
hdata_len);
if (!handle) {
silc_sftp_send_error(server, SILC_SFTP_STATUS_NO_SUCH_FILE, id);
break;
}
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_READDIR && server->monitor) {
(*server->monitor)(sftp, SILC_SFTP_MONITOR_READDIR, &mdata,
server->monitor_context);
}
/* Readdir operation */
server->fs->fs->sftp_readdir(server->fs->fs_context, sftp, handle,
silc_sftp_server_name, SILC_32_TO_PTR(id));
}
break;
case SILC_SFTP_STAT:
{
SILC_LOG_DEBUG(("Stat request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_STRING_ALLOC(&path),
SILC_STR_END);
if (ret < 0)
goto failure;
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_STAT && server->monitor) {
mdata.name = path;
(*server->monitor)(sftp, SILC_SFTP_MONITOR_STAT, &mdata,
server->monitor_context);
}
/* Stat operation */
server->fs->fs->sftp_stat(server->fs->fs_context, sftp, path,
silc_sftp_server_attr, SILC_32_TO_PTR(id));
silc_free(path);
}
break;
case SILC_SFTP_LSTAT:
{
SILC_LOG_DEBUG(("Lstat request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_STRING_ALLOC(&path),
SILC_STR_END);
if (ret < 0)
goto failure;
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_LSTAT && server->monitor) {
mdata.name = path;
(*server->monitor)(sftp, SILC_SFTP_MONITOR_LSTAT, &mdata,
server->monitor_context);
}
/* Lstat operation */
server->fs->fs->sftp_lstat(server->fs->fs_context, sftp, path,
silc_sftp_server_attr, SILC_32_TO_PTR(id));
silc_free(path);
}
break;
case SILC_SFTP_FSTAT:
{
unsigned char *hdata;
SilcUInt32 hdata_len;
SILC_LOG_DEBUG(("Fstat request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_NSTRING(&hdata,
&hdata_len),
SILC_STR_END);
if (ret < 0)
goto failure;
/* Get the handle */
handle = server->fs->fs->sftp_get_handle(server->fs->fs_context, sftp,
(const unsigned char *)hdata,
hdata_len);
if (!handle) {
silc_sftp_send_error(server, SILC_SFTP_STATUS_NO_SUCH_FILE, id);
break;
}
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_FSTAT && server->monitor) {
(*server->monitor)(sftp, SILC_SFTP_MONITOR_FSTAT, &mdata,
server->monitor_context);
}
/* Fstat operation */
server->fs->fs->sftp_fstat(server->fs->fs_context, sftp, handle,
silc_sftp_server_attr, SILC_32_TO_PTR(id));
}
break;
case SILC_SFTP_SETSTAT:
{
unsigned char *attr_buf;
SilcUInt32 attr_len = 0;
SilcBufferStruct tmpbuf;
SILC_LOG_DEBUG(("Setstat request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_STRING_ALLOC(&path),
SILC_STR_UI32_NSTRING(&attr_buf,
&attr_len),
SILC_STR_END);
if (ret < 0)
goto failure;
if (attr_len) {
silc_buffer_set(&tmpbuf, attr_buf, attr_len);
attrs = silc_sftp_attr_decode(&tmpbuf);
if (!attrs)
goto failure;
} else {
attrs = silc_calloc(1, sizeof(*attrs));
if (!attrs)
goto failure;
}
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_SETSTAT && server->monitor) {
mdata.name = path;
(*server->monitor)(sftp, SILC_SFTP_MONITOR_SETSTAT, &mdata,
server->monitor_context);
}
/* Setstat operation */
server->fs->fs->sftp_setstat(server->fs->fs_context, sftp, path, attrs,
silc_sftp_server_status,
SILC_32_TO_PTR(id));
silc_sftp_attr_free(attrs);
silc_free(path);
}
break;
case SILC_SFTP_FSETSTAT:
{
unsigned char *hdata, *attr_buf;
SilcUInt32 hdata_len, attr_len = 0;
SilcBufferStruct tmpbuf;
SILC_LOG_DEBUG(("Fsetstat request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_NSTRING(&hdata,
&hdata_len),
SILC_STR_UI32_NSTRING(&attr_buf,
&attr_len),
SILC_STR_END);
if (ret < 0)
goto failure;
if (attr_len) {
silc_buffer_set(&tmpbuf, attr_buf, attr_len);
attrs = silc_sftp_attr_decode(&tmpbuf);
if (!attrs)
goto failure;
} else {
attrs = silc_calloc(1, sizeof(*attrs));
if (!attrs)
goto failure;
}
/* Get the handle */
handle = server->fs->fs->sftp_get_handle(server->fs->fs_context, sftp,
(const unsigned char *)hdata,
hdata_len);
if (!handle) {
silc_sftp_send_error(server, SILC_SFTP_STATUS_NO_SUCH_FILE, id);
break;
}
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_FSETSTAT && server->monitor) {
(*server->monitor)(sftp, SILC_SFTP_MONITOR_FSETSTAT, &mdata,
server->monitor_context);
}
/* Fsetstat operation */
server->fs->fs->sftp_fsetstat(server->fs->fs_context, sftp,
handle, attrs,
silc_sftp_server_status,
SILC_32_TO_PTR(id));
silc_sftp_attr_free(attrs);
}
break;
case SILC_SFTP_READLINK:
{
SILC_LOG_DEBUG(("Readlink request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_STRING_ALLOC(&path),
SILC_STR_END);
if (ret < 0)
goto failure;
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_READLINK && server->monitor) {
mdata.name = path;
(*server->monitor)(sftp, SILC_SFTP_MONITOR_READLINK, &mdata,
server->monitor_context);
}
/* Readlink operation */
server->fs->fs->sftp_readlink(server->fs->fs_context, sftp, path,
silc_sftp_server_name, SILC_32_TO_PTR(id));
silc_free(path);
}
break;
case SILC_SFTP_SYMLINK:
{
char *target = NULL;
SILC_LOG_DEBUG(("Symlink request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_STRING_ALLOC(&path),
SILC_STR_UI32_STRING_ALLOC(&target),
SILC_STR_END);
if (ret < 0)
goto failure;
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_SYMLINK && server->monitor) {
mdata.name = path;
mdata.name2 = target;
(*server->monitor)(sftp, SILC_SFTP_MONITOR_SYMLINK, &mdata,
server->monitor_context);
}
/* Symlink operation */
server->fs->fs->sftp_symlink(server->fs->fs_context, sftp, path, target,
silc_sftp_server_status,
SILC_32_TO_PTR(id));
silc_free(path);
silc_free(target);
}
break;
case SILC_SFTP_REALPATH:
{
SILC_LOG_DEBUG(("Realpath request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_STRING_ALLOC(&path),
SILC_STR_END);
if (ret < 0)
goto failure;
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_REALPATH && server->monitor) {
mdata.name = path;
(*server->monitor)(sftp, SILC_SFTP_MONITOR_REALPATH, &mdata,
server->monitor_context);
}
/* Realpath operation */
server->fs->fs->sftp_realpath(server->fs->fs_context, sftp, path,
silc_sftp_server_name, SILC_32_TO_PTR(id));
silc_free(path);
}
break;
case SILC_SFTP_EXTENDED:
{
char *request = NULL;
unsigned char *data;
SilcUInt32 data_len;
SILC_LOG_DEBUG(("Extended request"));
ret = silc_buffer_unformat(&buf,
SILC_STR_UI_INT(&id),
SILC_STR_UI32_STRING_ALLOC(&request),
SILC_STR_END);
if (ret < 0)
goto failure;
data_len = 8 + strlen(request);
silc_buffer_pull(&buf, data_len);
ret = silc_buffer_unformat(&buf,
SILC_STR_DATA(&data, silc_buffer_len(&buf)),
SILC_STR_END);
if (ret < 0)
goto failure;
data_len = silc_buffer_len(&buf);
/* Call monitor */
if (server->monitors & SILC_SFTP_MONITOR_EXTENDED && server->monitor) {
(*server->monitor)(sftp, SILC_SFTP_MONITOR_EXTENDED, &mdata,
server->monitor_context);
}
/* Extended operation */
server->fs->fs->sftp_extended(server->fs->fs_context, sftp,
request, data, data_len,
silc_sftp_server_extended,
SILC_32_TO_PTR(id));
silc_free(request);
}
break;
default:
break;
}
return;
failure:
silc_sftp_send_error(server, SILC_SFTP_STATUS_FAILURE, id);
}
static char
silc_server_command_reply_whois_save(SilcServerCommandReplyContext cmd)
{
SilcServer server = cmd->server;
unsigned char *id_data, *umodes;
char *nickname, *username, *realname, *tmp;
unsigned char *fingerprint;
SilcID id;
SilcClientEntry client;
char global = FALSE;
char nick[128 + 1], servername[256 + 1], uname[128 + 1];
SilcUInt32 mode = 0, len, len2, id_len, flen;
const char *hostname, *ip;
silc_socket_stream_get_info(silc_packet_stream_get_stream(cmd->sock),
NULL, &hostname, &ip, NULL);
id_data = silc_argument_get_arg_type(cmd->args, 2, &id_len);
nickname = silc_argument_get_arg_type(cmd->args, 3, &len);
username = silc_argument_get_arg_type(cmd->args, 4, &len);
realname = silc_argument_get_arg_type(cmd->args, 5, &len);
if (!id_data || !nickname || !username || !realname)
return FALSE;
tmp = silc_argument_get_arg_type(cmd->args, 7, &len);
if (tmp)
SILC_GET32_MSB(mode, tmp);
if (!silc_id_payload_parse_id(id_data, id_len, &id))
return FALSE;
fingerprint = silc_argument_get_arg_type(cmd->args, 9, &flen);
/* Check if we have this client cached already. */
client = silc_idlist_find_client_by_id(server->local_list,
SILC_ID_GET_ID(id),
FALSE, NULL);
if (!client) {
client = silc_idlist_find_client_by_id(server->global_list,
SILC_ID_GET_ID(id),
FALSE, NULL);
global = TRUE;
}
if (!client) {
/* If router did not find such Client ID in its lists then this must
be bogus client or some router in the net is buggy. */
if (server->server_type != SILC_SERVER)
return FALSE;
/* Take hostname out of nick string if it includes it. */
silc_parse_userfqdn(nickname, nick, sizeof(nick), servername,
sizeof(servername));
/* We don't have that client anywhere, add it. The client is added
to global list since server didn't have it in the lists so it must be
global. This will check for valid nickname and username strings. */
client = silc_idlist_add_client(server->global_list,
strdup(nick), username,
strdup(realname),
silc_id_dup(SILC_ID_GET_ID(id),
SILC_ID_CLIENT),
silc_packet_get_context(cmd->sock),
NULL);
if (!client) {
SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
return FALSE;
}
client->data.status |=
(SILC_IDLIST_STATUS_REGISTERED | SILC_IDLIST_STATUS_RESOLVED);
client->data.status &= ~SILC_IDLIST_STATUS_RESOLVING;
client->mode = mode;
client->servername = servername[0] ? strdup(servername) : NULL;
SILC_LOG_DEBUG(("stat.clients %d->%d", server->stat.clients,
server->stat.clients + 1));
server->stat.clients++;
} else {
/* We have the client already, update the data */
SILC_LOG_DEBUG(("Updating client data"));
/* Check nickname */
silc_parse_userfqdn(nickname, nick, sizeof(nick), servername,
sizeof(servername));
nickname = silc_identifier_check(nick, strlen(nick), SILC_STRING_UTF8,
128, NULL);
if (!nickname) {
SILC_LOG_ERROR(("Malformed nickname '%s' received in WHOIS reply "
"from %s",
hostname ? hostname : "", nick));
return FALSE;
}
/* Check username */
silc_parse_userfqdn(username, uname, sizeof(uname), NULL, 0);
if (!silc_identifier_verify(uname, strlen(uname), SILC_STRING_UTF8, 128)) {
SILC_LOG_ERROR(("Malformed username '%s' received in WHOIS reply "
"from %s",
hostname ? hostname : "", tmp));
return FALSE;
}
/* Update entry */
silc_idcache_update_by_context(global ? server->global_list->clients :
server->local_list->clients, client, NULL,
nickname, TRUE);
silc_free(client->nickname);
silc_free(client->username);
silc_free(client->userinfo);
silc_free(client->servername);
client->nickname = strdup(nick);
client->username = strdup(username);
client->userinfo = strdup(realname);
client->servername = servername[0] ? strdup(servername) : NULL;
client->mode = mode;
client->data.status |= SILC_IDLIST_STATUS_RESOLVED;
client->data.status &= ~SILC_IDLIST_STATUS_RESOLVING;
}
/* Save channel list if it was sent to us */
if (server->server_type == SILC_SERVER) {
tmp = silc_argument_get_arg_type(cmd->args, 6, &len);
umodes = silc_argument_get_arg_type(cmd->args, 10, &len2);
if (tmp && umodes) {
SilcBufferStruct channels_buf, umodes_buf;
silc_buffer_set(&channels_buf, tmp, len);
silc_buffer_set(&umodes_buf, umodes, len2);
silc_server_save_user_channels(server, cmd->sock, client, &channels_buf,
&umodes_buf);
} else {
silc_server_save_user_channels(server, cmd->sock, client, NULL, NULL);
}
}
if (fingerprint && flen == sizeof(client->data.fingerprint))
memcpy(client->data.fingerprint, fingerprint, flen);
/* Take Requested Attributes if set. */
tmp = silc_argument_get_arg_type(cmd->args, 11, &len);
if (tmp) {
silc_free(client->attrs);
client->attrs = silc_memdup(tmp, len);
client->attrs_len = len;
/* Try to take public key from attributes if present and we don't have
the key already. Do this only on normal server. Routers do GETKEY
for all clients anyway. */
if (server->server_type != SILC_ROUTER && !client->data.public_key) {
SilcAttributePayload attr;
SilcAttributeObjPk pk;
unsigned char f[SILC_HASH_MAXLEN];
SilcDList attrs = silc_attribute_payload_parse(tmp, len);
SILC_LOG_DEBUG(("Take client public key from attributes"));
if (attrs) {
silc_dlist_start(attrs);
while ((attr = silc_dlist_get(attrs)) != SILC_LIST_END) {
if (silc_attribute_get_attribute(attr) ==
SILC_ATTRIBUTE_USER_PUBLIC_KEY) {
if (!silc_attribute_get_object(attr, &pk, sizeof(pk)))
continue;
/* Take only SILC public keys */
if (strcmp(pk.type, "silc-rsa")) {
silc_free(pk.type);
silc_free(pk.data);
continue;
}
/* Verify that the server provided fingerprint matches the key */
silc_hash_make(server->sha1hash, pk.data, pk.data_len, f);
if (memcmp(f, client->data.fingerprint, sizeof(f))) {
silc_free(pk.type);
silc_free(pk.data);
continue;
}
/* Save the public key. */
if (!silc_pkcs_public_key_alloc(SILC_PKCS_SILC,
pk.data, pk.data_len,
&client->data.public_key)) {
silc_free(pk.type);
silc_free(pk.data);
continue;
}
SILC_LOG_DEBUG(("Saved client public key from attributes"));
/* Add client's public key to repository */
if (!silc_server_get_public_key_by_client(server, client, NULL))
silc_skr_add_public_key_simple(server->repository,
client->data.public_key,
SILC_SKR_USAGE_IDENTIFICATION,
client, NULL);
silc_free(pk.type);
silc_free(pk.data);
break;
}
}
silc_attribute_payload_list_free(attrs);
}
}
}
return TRUE;
}
SilcBool silc_pkcs1_verify(void *public_key,
unsigned char *signature,
SilcUInt32 signature_len,
unsigned char *data,
SilcUInt32 data_len,
SilcHash hash)
{
RsaPublicKey *key = public_key;
SilcBool ret = FALSE;
SilcMPInt mp_tmp2;
SilcMPInt mp_dst;
unsigned char *verify, unpadded[2048 + 1], hashr[SILC_HASH_MAXLEN];
SilcUInt32 verify_len, len = (key->bits + 7) / 8;
SilcBufferStruct di, ldi;
SilcHash ihash = NULL;
SilcAsn1 asn1 = NULL;
char *oid;
SILC_LOG_DEBUG(("Verify signature"));
asn1 = silc_asn1_alloc();
if (!asn1)
return FALSE;
silc_mp_init(&mp_tmp2);
silc_mp_init(&mp_dst);
/* Format the signature into MP int */
silc_mp_bin2mp(signature, signature_len, &mp_tmp2);
/* Verify */
silc_rsa_public_operation(key, &mp_tmp2, &mp_dst);
/* MP to data */
verify = silc_mp_mp2bin(&mp_dst, len, &verify_len);
/* Unpad data */
if (!silc_pkcs1_decode(SILC_PKCS1_BT_PRV1, verify, verify_len,
unpadded, sizeof(unpadded), &len))
goto err;
silc_buffer_set(&di, unpadded, len);
/* If hash isn't given, allocate the one given in digest info */
if (!hash) {
/* Decode digest info */
if (!silc_asn1_decode(asn1, &di,
SILC_ASN1_OPTS(SILC_ASN1_ACCUMUL),
SILC_ASN1_SEQUENCE,
SILC_ASN1_SEQUENCE,
SILC_ASN1_OID(&oid),
SILC_ASN1_END,
SILC_ASN1_END, SILC_ASN1_END))
goto err;
if (!silc_hash_alloc_by_oid(oid, &ihash)) {
SILC_LOG_DEBUG(("Unknown OID %s", oid));
goto err;
}
hash = ihash;
}
/* Hash the data */
silc_hash_make(hash, data, data_len, hashr);
data = hashr;
data_len = silc_hash_len(hash);
oid = (char *)silc_hash_get_oid(hash);
/* Encode digest info for comparison */
memset(&ldi, 0, sizeof(ldi));
if (!silc_asn1_encode(asn1, &ldi,
SILC_ASN1_OPTS(SILC_ASN1_ACCUMUL),
SILC_ASN1_SEQUENCE,
SILC_ASN1_SEQUENCE,
SILC_ASN1_OID(oid),
SILC_ASN1_NULL,
SILC_ASN1_END,
SILC_ASN1_OCTET_STRING(data, data_len),
SILC_ASN1_END, SILC_ASN1_END))
goto err;
SILC_LOG_HEXDUMP(("DigestInfo remote"), silc_buffer_data(&di),
silc_buffer_len(&di));
SILC_LOG_HEXDUMP(("DigestInfo local"), silc_buffer_data(&ldi),
silc_buffer_len(&ldi));
/* Compare */
if (silc_buffer_len(&di) == silc_buffer_len(&ldi) &&
!memcmp(silc_buffer_data(&di), silc_buffer_data(&ldi),
silc_buffer_len(&ldi)))
ret = TRUE;
memset(verify, 0, verify_len);
memset(unpadded, 0, sizeof(unpadded));
silc_free(verify);
silc_mp_uninit(&mp_tmp2);
silc_mp_uninit(&mp_dst);
if (hash)
memset(hashr, 0, sizeof(hashr));
if (ihash)
silc_hash_free(ihash);
silc_asn1_free(asn1);
return ret;
err:
memset(verify, 0, verify_len);
silc_free(verify);
silc_mp_uninit(&mp_tmp2);
silc_mp_uninit(&mp_dst);
if (ihash)
silc_hash_free(ihash);
silc_asn1_free(asn1);
return FALSE;
}
