diff options
Diffstat (limited to 'rpc_server.c')
| -rw-r--r-- | rpc_server.c | 409 |
1 files changed, 286 insertions, 123 deletions
diff --git a/rpc_server.c b/rpc_server.c index a0de42d..a21679a 100644 --- a/rpc_server.c +++ b/rpc_server.c @@ -44,6 +44,8 @@ #define pad(n) (((n) + 3) & ~3) +#define nargs(n) ((n) * 4) + static hal_error_t get_version(const uint8_t **iptr, const uint8_t * const ilimit, uint8_t **optr, const uint8_t * const olimit) { @@ -54,7 +56,8 @@ static hal_error_t get_version(const uint8_t **iptr, const uint8_t * const ilimi check(hal_xdr_decode_int(iptr, ilimit, &client.handle)); /* call the local function */ - ret = hal_rpc_local_misc_dispatch.get_version(&version); + ret = hal_rpc_get_version(&version); + if (ret == HAL_OK) check(hal_xdr_encode_int(optr, olimit, version)); @@ -77,7 +80,7 @@ static hal_error_t get_random(const uint8_t **iptr, const uint8_t * const ilimit /* call the local function */ /* get the data directly into the output buffer */ check(hal_xdr_encode_int(optr, olimit, length)); - ret = hal_rpc_local_misc_dispatch.get_random(*optr, (size_t)length); + ret = hal_rpc_get_random(*optr, (size_t)length); if (ret == HAL_OK) *optr += pad(length); else @@ -101,7 +104,8 @@ static hal_error_t set_pin(const uint8_t **iptr, const uint8_t * const ilimit, check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &pin, &pin_len)); /* call the local function */ - ret = hal_rpc_local_misc_dispatch.set_pin(client, user, (const char * const)pin, pin_len); + ret = hal_rpc_set_pin(client, user, (const char * const)pin, pin_len); + return ret; } @@ -119,7 +123,8 @@ static hal_error_t login(const uint8_t **iptr, const uint8_t * const ilimit, check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &pin, &pin_len)); /* call the local function */ - ret = hal_rpc_local_misc_dispatch.login(client, user, (const char * const)pin, pin_len); + ret = hal_rpc_login(client, user, (const char * const)pin, pin_len); + return ret; } @@ -132,7 +137,8 @@ static hal_error_t logout(const uint8_t **iptr, const uint8_t * const ilimit, check(hal_xdr_decode_int(iptr, ilimit, &client.handle)); /* call the local function */ - ret = hal_rpc_local_misc_dispatch.logout(client); + ret = hal_rpc_logout(client); + return ret; } @@ -145,7 +151,8 @@ static hal_error_t logout_all(const uint8_t **iptr, const uint8_t * const ilimit check(hal_xdr_decode_int(iptr, ilimit, &client.handle)); /* call the local function */ - ret = hal_rpc_local_misc_dispatch.logout_all(); + ret = hal_rpc_logout_all(); + return ret; } @@ -160,7 +167,8 @@ static hal_error_t is_logged_in(const uint8_t **iptr, const uint8_t * const ilim check(hal_xdr_decode_int(iptr, ilimit, &user)); /* call the local function */ - ret = hal_rpc_local_misc_dispatch.is_logged_in(client, user); + ret = hal_rpc_is_logged_in(client, user); + return ret; } @@ -176,9 +184,11 @@ static hal_error_t hash_get_digest_len(const uint8_t **iptr, const uint8_t * con check(hal_xdr_decode_int(iptr, ilimit, &alg)); /* call the local function */ - ret = hal_rpc_local_hash_dispatch.get_digest_length(alg, &length); + ret = hal_rpc_hash_get_digest_length(alg, &length); + if (ret == HAL_OK) check(hal_xdr_encode_int(optr, olimit, length)); + return ret; } @@ -202,7 +212,7 @@ static hal_error_t hash_get_digest_algorithm_id(const uint8_t **iptr, const uint /* call the local function */ /* get the data directly into the output buffer */ *optr += 4; /* reserve 4 bytes for length */ - ret = hal_rpc_local_hash_dispatch.get_digest_algorithm_id(alg, *optr, &len, (size_t)len_max); + ret = hal_rpc_hash_get_digest_algorithm_id(alg, *optr, &len, (size_t)len_max); if (ret == HAL_OK) { *optr = optr_orig; check(hal_xdr_encode_int(optr, olimit, len)); @@ -227,9 +237,11 @@ static hal_error_t hash_get_algorithm(const uint8_t **iptr, const uint8_t * cons check(hal_xdr_decode_int(iptr, ilimit, &hash.handle)); /* call the local function */ - ret = hal_rpc_local_hash_dispatch.get_algorithm(hash, &alg); + ret = hal_rpc_hash_get_algorithm(hash, &alg); + if (ret == HAL_OK) check(hal_xdr_encode_int(optr, olimit, alg)); + return ret; } @@ -250,9 +262,11 @@ static hal_error_t hash_initialize(const uint8_t **iptr, const uint8_t * const i check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &key, &key_len)); /* call the local function */ - ret = hal_rpc_local_hash_dispatch.initialize(client, session, &hash, (hal_digest_algorithm_t)alg, key, (size_t)key_len); + ret = hal_rpc_hash_initialize(client, session, &hash, (hal_digest_algorithm_t)alg, key, (size_t)key_len); + if (ret == HAL_OK) check(hal_xdr_encode_int(optr, olimit, hash.handle)); + return ret; } @@ -270,7 +284,8 @@ static hal_error_t hash_update(const uint8_t **iptr, const uint8_t * const ilimi check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &data, &length)); /* call the local function */ - ret = hal_rpc_local_hash_dispatch.update(hash, data, (size_t)length); + ret = hal_rpc_hash_update(hash, data, (size_t)length); + return ret; } @@ -292,7 +307,7 @@ static hal_error_t hash_finalize(const uint8_t **iptr, const uint8_t * const ili /* call the local function */ /* get the data directly into the output buffer */ check(hal_xdr_encode_int(optr, olimit, length)); - ret = hal_rpc_local_hash_dispatch.finalize(hash, *optr, (size_t)length); + ret = hal_rpc_hash_finalize(hash, *optr, (size_t)length); if (ret == HAL_OK) *optr += pad(length); else @@ -309,8 +324,9 @@ static hal_error_t pkey_load(const uint8_t **iptr, const uint8_t * const ilimit, hal_pkey_handle_t pkey; uint32_t type; uint32_t curve; - const uint8_t *name, *der; - uint32_t name_len, der_len; + hal_uuid_t name; + const uint8_t *der; + uint32_t der_len; hal_key_flags_t flags; hal_error_t ret; @@ -318,39 +334,47 @@ static hal_error_t pkey_load(const uint8_t **iptr, const uint8_t * const ilimit, check(hal_xdr_decode_int(iptr, ilimit, &session.handle)); check(hal_xdr_decode_int(iptr, ilimit, &type)); check(hal_xdr_decode_int(iptr, ilimit, &curve)); - check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &name, &name_len)); check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &der, &der_len)); check(hal_xdr_decode_int(iptr, ilimit, &flags)); /* call the local function */ - ret = hal_rpc_local_pkey_dispatch.load(client, session, &pkey, type, curve, name, name_len, der, der_len, flags); - if (ret == HAL_OK) - check(hal_xdr_encode_int(optr, olimit, pkey.handle)); + ret = hal_rpc_pkey_load(client, session, &pkey, type, curve, &name, der, der_len, flags); + + if (ret == HAL_OK) { + uint8_t *optr_orig = *optr; + if ((ret = hal_xdr_encode_int(optr, olimit, pkey.handle)) != HAL_OK || + (ret = hal_xdr_encode_buffer(optr, olimit, name.uuid, sizeof(name.uuid))) != HAL_OK) + *optr = optr_orig; + } + return ret; } -static hal_error_t pkey_find(const uint8_t **iptr, const uint8_t * const ilimit, +static hal_error_t pkey_open(const uint8_t **iptr, const uint8_t * const ilimit, uint8_t **optr, const uint8_t * const olimit) { hal_client_handle_t client; hal_session_handle_t session; hal_pkey_handle_t pkey; - uint32_t type; - const uint8_t *name; + const uint8_t *name_ptr; uint32_t name_len; hal_key_flags_t flags; hal_error_t ret; check(hal_xdr_decode_int(iptr, ilimit, &client.handle)); check(hal_xdr_decode_int(iptr, ilimit, &session.handle)); - check(hal_xdr_decode_int(iptr, ilimit, &type)); - check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &name, &name_len)); + check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &name_ptr, &name_len)); check(hal_xdr_decode_int(iptr, ilimit, &flags)); + if (name_len != sizeof(hal_uuid_t)) + return HAL_ERROR_KEY_NAME_TOO_LONG; + /* call the local function */ - ret = hal_rpc_local_pkey_dispatch.find(client, session, &pkey, type, name, name_len, flags); + ret = hal_rpc_pkey_open(client, session, &pkey, (const hal_uuid_t *) name_ptr, flags); + if (ret == HAL_OK) check(hal_xdr_encode_int(optr, olimit, pkey.handle)); + return ret; } @@ -360,8 +384,7 @@ static hal_error_t pkey_generate_rsa(const uint8_t **iptr, const uint8_t * const hal_client_handle_t client; hal_session_handle_t session; hal_pkey_handle_t pkey; - const uint8_t *name; - uint32_t name_len; + hal_uuid_t name; uint32_t key_len; const uint8_t *exp; uint32_t exp_len; @@ -370,15 +393,20 @@ static hal_error_t pkey_generate_rsa(const uint8_t **iptr, const uint8_t * const check(hal_xdr_decode_int(iptr, ilimit, &client.handle)); check(hal_xdr_decode_int(iptr, ilimit, &session.handle)); - check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &name, &name_len)); check(hal_xdr_decode_int(iptr, ilimit, &key_len)); check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &exp, &exp_len)); check(hal_xdr_decode_int(iptr, ilimit, &flags)); /* call the local function */ - ret = hal_rpc_local_pkey_dispatch.generate_rsa(client, session, &pkey, name, name_len, key_len, exp, exp_len, flags); - if (ret == HAL_OK) - check(hal_xdr_encode_int(optr, olimit, pkey.handle)); + ret = hal_rpc_pkey_generate_rsa(client, session, &pkey, &name, key_len, exp, exp_len, flags); + + if (ret == HAL_OK) { + uint8_t *optr_orig = *optr; + if ((ret = hal_xdr_encode_int(optr, olimit, pkey.handle)) != HAL_OK || + (ret = hal_xdr_encode_buffer(optr, olimit, name.uuid, sizeof(name.uuid))) != HAL_OK) + *optr = optr_orig; + } + return ret; } @@ -388,22 +416,26 @@ static hal_error_t pkey_generate_ec(const uint8_t **iptr, const uint8_t * const hal_client_handle_t client; hal_session_handle_t session; hal_pkey_handle_t pkey; - const uint8_t *name; - uint32_t name_len; + hal_uuid_t name; uint32_t curve; hal_key_flags_t flags; hal_error_t ret; check(hal_xdr_decode_int(iptr, ilimit, &client.handle)); check(hal_xdr_decode_int(iptr, ilimit, &session.handle)); - check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &name, &name_len)); check(hal_xdr_decode_int(iptr, ilimit, &curve)); check(hal_xdr_decode_int(iptr, ilimit, &flags)); /* call the local function */ - ret = hal_rpc_local_pkey_dispatch.generate_ec(client, session, &pkey, name, name_len, curve, flags); - if (ret == HAL_OK) - check(hal_xdr_encode_int(optr, olimit, pkey.handle)); + ret = hal_rpc_pkey_generate_ec(client, session, &pkey, &name, curve, flags); + + if (ret == HAL_OK) { + uint8_t *optr_orig = *optr; + if ((ret = hal_xdr_encode_int(optr, olimit, pkey.handle)) != HAL_OK || + (ret = hal_xdr_encode_buffer(optr, olimit, name.uuid, sizeof(name.uuid))) != HAL_OK) + *optr = optr_orig; + } + return ret; } @@ -418,7 +450,8 @@ static hal_error_t pkey_close(const uint8_t **iptr, const uint8_t * const ilimit check(hal_xdr_decode_int(iptr, ilimit, &pkey.handle)); /* call the local function */ - ret = hal_rpc_local_pkey_dispatch.close(pkey); + ret = hal_rpc_pkey_close(pkey); + return ret; } @@ -433,43 +466,48 @@ static hal_error_t pkey_delete(const uint8_t **iptr, const uint8_t * const ilimi check(hal_xdr_decode_int(iptr, ilimit, &pkey.handle)); /* call the local function */ - ret = hal_rpc_local_pkey_dispatch.delete(pkey); + ret = hal_rpc_pkey_delete(pkey); + return ret; } -static hal_error_t pkey_rename(const uint8_t **iptr, const uint8_t * const ilimit, - uint8_t **optr, const uint8_t * const olimit) +static hal_error_t pkey_get_key_type(const uint8_t **iptr, const uint8_t * const ilimit, + uint8_t **optr, const uint8_t * const olimit) { hal_client_handle_t client __attribute__((unused)); hal_pkey_handle_t pkey; - const uint8_t *name; - uint32_t name_len; + hal_key_type_t type; hal_error_t ret; check(hal_xdr_decode_int(iptr, ilimit, &client.handle)); check(hal_xdr_decode_int(iptr, ilimit, &pkey.handle)); - check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &name, &name_len)); /* call the local function */ - ret = hal_rpc_local_pkey_dispatch.rename(pkey, name, name_len); + ret = hal_rpc_pkey_get_key_type(pkey, &type); + + if (ret == HAL_OK) + check(hal_xdr_encode_int(optr, olimit, type)); + return ret; } -static hal_error_t pkey_get_key_type(const uint8_t **iptr, const uint8_t * const ilimit, +static hal_error_t pkey_get_key_curve(const uint8_t **iptr, const uint8_t * const ilimit, uint8_t **optr, const uint8_t * const olimit) { - hal_client_handle_t client __attribute__((unused)); + hal_client_handle_t client; hal_pkey_handle_t pkey; - hal_key_type_t type; + hal_curve_name_t curve; hal_error_t ret; check(hal_xdr_decode_int(iptr, ilimit, &client.handle)); check(hal_xdr_decode_int(iptr, ilimit, &pkey.handle)); /* call the local function */ - ret = hal_rpc_local_pkey_dispatch.get_key_type(pkey, &type); + ret = hal_rpc_pkey_get_key_curve(pkey, &curve); + if (ret == HAL_OK) - check(hal_xdr_encode_int(optr, olimit, type)); + check(hal_xdr_encode_int(optr, olimit, curve)); + return ret; } @@ -485,9 +523,11 @@ static hal_error_t pkey_get_key_flags(const uint8_t **iptr, const uint8_t * cons check(hal_xdr_decode_int(iptr, ilimit, &pkey.handle)); /* call the local function */ - ret = hal_rpc_local_pkey_dispatch.get_key_flags(pkey, &flags); + ret = hal_rpc_pkey_get_key_flags(pkey, &flags); + if (ret == HAL_OK) check(hal_xdr_encode_int(optr, olimit, flags)); + return ret; } @@ -502,8 +542,10 @@ static hal_error_t pkey_get_public_key_len(const uint8_t **iptr, const uint8_t * check(hal_xdr_decode_int(iptr, ilimit, &pkey.handle)); /* call the local function */ - len = hal_rpc_local_pkey_dispatch.get_public_key_len(pkey); + len = hal_rpc_pkey_get_public_key_len(pkey); + check(hal_xdr_encode_int(optr, olimit, len)); + return HAL_OK; } @@ -527,7 +569,7 @@ static hal_error_t pkey_get_public_key(const uint8_t **iptr, const uint8_t * con /* call the local function */ /* get the data directly into the output buffer */ *optr += 4; /* reserve 4 bytes for length */ - ret = hal_rpc_local_pkey_dispatch.get_public_key(pkey, *optr, &len, len_max); + ret = hal_rpc_pkey_get_public_key(pkey, *optr, &len, len_max); if (ret == HAL_OK) { *optr = optr_orig; check(hal_xdr_encode_int(optr, olimit, len)); @@ -540,11 +582,10 @@ static hal_error_t pkey_get_public_key(const uint8_t **iptr, const uint8_t * con return ret; } -static hal_error_t pkey_remote_sign(const uint8_t **iptr, const uint8_t * const ilimit, - uint8_t **optr, const uint8_t * const olimit) +static hal_error_t pkey_sign(const uint8_t **iptr, const uint8_t * const ilimit, + uint8_t **optr, const uint8_t * const olimit) { - hal_client_handle_t client __attribute__((unused)); - hal_session_handle_t session; + hal_client_handle_t client; hal_pkey_handle_t pkey; hal_hash_handle_t hash; const uint8_t *input; @@ -555,7 +596,6 @@ static hal_error_t pkey_remote_sign(const uint8_t **iptr, const uint8_t * const hal_error_t ret; check(hal_xdr_decode_int(iptr, ilimit, &client.handle)); - check(hal_xdr_decode_int(iptr, ilimit, &session.handle)); check(hal_xdr_decode_int(iptr, ilimit, &pkey.handle)); check(hal_xdr_decode_int(iptr, ilimit, &hash.handle)); check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &input, &input_len)); @@ -567,7 +607,7 @@ static hal_error_t pkey_remote_sign(const uint8_t **iptr, const uint8_t * const /* call the local function */ /* get the data directly into the output buffer */ *optr += 4; /* reserve 4 bytes for length */ - ret = hal_rpc_local_pkey_dispatch.sign(session, pkey, hash, input, input_len, *optr, &sig_len, sig_max); + ret = hal_rpc_pkey_sign(pkey, hash, input, input_len, *optr, &sig_len, sig_max); *optr = optr_orig; if (ret == HAL_OK) { check(hal_xdr_encode_int(optr, olimit, sig_len)); @@ -576,11 +616,10 @@ static hal_error_t pkey_remote_sign(const uint8_t **iptr, const uint8_t * const return ret; } -static hal_error_t pkey_remote_verify(const uint8_t **iptr, const uint8_t * const ilimit, - uint8_t **optr, const uint8_t * const olimit) +static hal_error_t pkey_verify(const uint8_t **iptr, const uint8_t * const ilimit, + uint8_t **optr, const uint8_t * const olimit) { - hal_client_handle_t client __attribute__((unused)); - hal_session_handle_t session; + hal_client_handle_t client; hal_pkey_handle_t pkey; hal_hash_handle_t hash; const uint8_t *input; @@ -590,62 +629,160 @@ static hal_error_t pkey_remote_verify(const uint8_t **iptr, const uint8_t * cons hal_error_t ret; check(hal_xdr_decode_int(iptr, ilimit, &client.handle)); - check(hal_xdr_decode_int(iptr, ilimit, &session.handle)); check(hal_xdr_decode_int(iptr, ilimit, &pkey.handle)); check(hal_xdr_decode_int(iptr, ilimit, &hash.handle)); check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &input, &input_len)); check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &sig, &sig_len)); /* call the local function */ - ret = hal_rpc_local_pkey_dispatch.verify(session, pkey, hash, input, input_len, sig, sig_len); + ret = hal_rpc_pkey_verify(pkey, hash, input, input_len, sig, sig_len); + return ret; } -static hal_error_t hal_xdr_encode_pkey_info(uint8_t **optr, const uint8_t * const olimit, const hal_pkey_info_t *info) +static hal_error_t pkey_match(const uint8_t **iptr, const uint8_t * const ilimit, + uint8_t **optr, const uint8_t * const olimit) { - uint8_t *optr_orig = *optr; + hal_client_handle_t client; + hal_session_handle_t session; + uint32_t type, curve, attributes_len, result_max, previous_uuid_len; + const uint8_t *previous_uuid_ptr; + hal_key_flags_t flags; hal_error_t ret; - if ((ret = hal_xdr_encode_int(optr, olimit, info->type)) != HAL_OK || - (ret = hal_xdr_encode_int(optr, olimit, info->curve)) != HAL_OK || - (ret = hal_xdr_encode_int(optr, olimit, info->flags)) != HAL_OK || - (ret = hal_xdr_encode_buffer(optr, olimit, (uint8_t *)&info->name[0], info->name_len)) != HAL_OK) - *optr = optr_orig; + check(hal_xdr_decode_int(iptr, ilimit, &client.handle)); + check(hal_xdr_decode_int(iptr, ilimit, &session.handle)); + check(hal_xdr_decode_int(iptr, ilimit, &type)); + check(hal_xdr_decode_int(iptr, ilimit, &curve)); + check(hal_xdr_decode_int(iptr, ilimit, &flags)); + check(hal_xdr_decode_int(iptr, ilimit, &attributes_len)); + + hal_pkey_attribute_t attributes[attributes_len > 0 ? attributes_len : 1]; + + for (int i = 0; i < attributes_len; i++) { + hal_pkey_attribute_t *a = &attributes[i]; + const uint8_t *value; + uint32_t value_len; + check(hal_xdr_decode_int(iptr, ilimit, &a->type)); + check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &value, &value_len)); + a->value = value; + a->length = value_len; + } + + check(hal_xdr_decode_int(iptr, ilimit, &result_max)); + check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &previous_uuid_ptr, &previous_uuid_len)); + + if (previous_uuid_len != sizeof(hal_uuid_t)) + return HAL_ERROR_KEY_NAME_TOO_LONG; + + const hal_uuid_t * const previous_uuid = (const void *) previous_uuid_ptr; + + hal_uuid_t result[result_max]; + unsigned result_len; + + ret = hal_rpc_pkey_match(client, session, type, curve, flags, + attributes, attributes_len, + result, &result_len, result_max, + previous_uuid); + + if (ret == HAL_OK) { + uint8_t *optr_orig = *optr; + ret = hal_xdr_encode_int(optr, olimit, result_len); + for (int i = 0; ret == HAL_OK && i < result_len; ++i) + ret = hal_xdr_encode_buffer(optr, olimit, result[i].uuid, + sizeof(result[i].uuid)); + if (ret != HAL_OK) + *optr = optr_orig; + } + return ret; } +static hal_error_t pkey_set_attributes(const uint8_t **iptr, const uint8_t * const ilimit, + uint8_t **optr, const uint8_t * const olimit) +{ + hal_client_handle_t client; + hal_pkey_handle_t pkey; + uint32_t attributes_len; + hal_error_t ret; -static hal_error_t pkey_list(const uint8_t **iptr, const uint8_t * const ilimit, - uint8_t **optr, const uint8_t * const olimit) + check(hal_xdr_decode_int(iptr, ilimit, &client.handle)); + check(hal_xdr_decode_int(iptr, ilimit, &pkey.handle)); + check(hal_xdr_decode_int(iptr, ilimit, &attributes_len)); + + hal_pkey_attribute_t attributes[attributes_len > 0 ? attributes_len : 1]; + + for (int i = 0; i < attributes_len; i++) { + hal_pkey_attribute_t *a = &attributes[i]; + check(hal_xdr_decode_int(iptr, ilimit, &a->type)); + const uint8_t *iptr_prior_to_decoding_length = *iptr; + check(hal_xdr_decode_int(iptr, ilimit, &a->length)); + if (a->length == HAL_PKEY_ATTRIBUTE_NIL) { + a->value = NULL; + } + else { + *iptr = iptr_prior_to_decoding_length; + const uint8_t *value; + check(hal_xdr_decode_buffer_in_place(iptr, ilimit, &value, &a->length)); + a->value = value; + } + } + + ret = hal_rpc_pkey_set_attributes(pkey, attributes, attributes_len); + + return ret; +} + +static hal_error_t pkey_get_attributes(const uint8_t **iptr, const uint8_t * const ilimit, + uint8_t **optr, const uint8_t * const olimit) { - hal_client_handle_t client __attribute__((unused)); + hal_client_handle_t client; + hal_pkey_handle_t pkey; + uint32_t attributes_len, u32; uint8_t *optr_orig = *optr; - uint32_t result_max; - hal_key_flags_t flags; hal_error_t ret; check(hal_xdr_decode_int(iptr, ilimit, &client.handle)); - check(hal_xdr_decode_int(iptr, ilimit, &result_max)); - check(hal_xdr_decode_int(iptr, ilimit, &flags)); + check(hal_xdr_decode_int(iptr, ilimit, &pkey.handle)); + check(hal_xdr_decode_int(iptr, ilimit, &attributes_len)); - hal_pkey_info_t result[result_max]; - unsigned result_len; + hal_pkey_attribute_t attributes[attributes_len > 0 ? attributes_len : 1]; + + for (int i = 0; i < attributes_len; i++) + check(hal_xdr_decode_int(iptr, ilimit, &attributes[i].type)); + + check(hal_xdr_decode_int(iptr, ilimit, &u32)); + + const size_t attributes_buffer_len = u32; + + if (nargs(1 + 2 * attributes_len) + attributes_buffer_len > olimit - *optr) + return HAL_ERROR_RPC_PACKET_OVERFLOW; + + uint8_t attributes_buffer[attributes_buffer_len > 0 ? attributes_buffer_len : 1]; + + ret = hal_rpc_pkey_get_attributes(pkey, attributes, attributes_len, + attributes_buffer, attributes_buffer_len); - /* call the local function */ - ret = hal_rpc_local_pkey_dispatch.list(result, &result_len, result_max, flags); if (ret == HAL_OK) { - int i; - check(hal_xdr_encode_int(optr, olimit, result_len)); - for (i = 0; i < result_len; ++i) { - if ((ret = hal_xdr_encode_pkey_info(optr, olimit, &result[i])) != HAL_OK) { - *optr = optr_orig; + ret = hal_xdr_encode_int(optr, olimit, attributes_len); + for (int i = 0; ret == HAL_OK && i < attributes_len; i++) { + ret = hal_xdr_encode_int(optr, olimit, attributes[i].type); + if (ret != HAL_OK) break; - } + if (attributes_buffer_len == 0) + ret = hal_xdr_encode_int(optr, olimit, attributes[i].length); + else + ret = hal_xdr_encode_buffer(optr, olimit, attributes[i].value, attributes[i].length); } } + + if (ret != HAL_OK) + *optr = optr_orig; + return ret; } + hal_error_t hal_rpc_server_dispatch(const uint8_t * const ibuf, const size_t ilen, uint8_t * const obuf, size_t * const olen) { @@ -656,96 +793,108 @@ hal_error_t hal_rpc_server_dispatch(const uint8_t * const ibuf, const size_t ile uint32_t rpc_func_num; uint32_t client_handle; hal_error_t ret; + hal_error_t (*handler)(const uint8_t **iptr, const uint8_t * const ilimit, + uint8_t **optr, const uint8_t * const olimit) = NULL; check(hal_xdr_decode_int(&iptr, ilimit, &rpc_func_num)); check(hal_xdr_decode_int(&iptr, ilimit, &client_handle)); check(hal_xdr_undecode_int(&iptr)); + switch (rpc_func_num) { case RPC_FUNC_GET_VERSION: - ret = get_version(&iptr, ilimit, &optr, olimit); + handler = get_version; break; case RPC_FUNC_GET_RANDOM: - ret = get_random(&iptr, ilimit, &optr, olimit); + handler = get_random; break; case RPC_FUNC_SET_PIN: - ret = set_pin(&iptr, ilimit, &optr, olimit); + handler = set_pin; break; case RPC_FUNC_LOGIN: - ret = login(&iptr, ilimit, &optr, olimit); + handler = login; break; case RPC_FUNC_LOGOUT: - ret = logout(&iptr, ilimit, &optr, olimit); + handler = logout; break; case RPC_FUNC_LOGOUT_ALL: - ret = logout_all(&iptr, ilimit, &optr, olimit); + handler = logout_all; break; case RPC_FUNC_IS_LOGGED_IN: - ret = is_logged_in(&iptr, ilimit, &optr, olimit); + handler = is_logged_in; break; case RPC_FUNC_HASH_GET_DIGEST_LEN: - ret = hash_get_digest_len(&iptr, ilimit, &optr, olimit); + handler = hash_get_digest_len; break; case RPC_FUNC_HASH_GET_DIGEST_ALGORITHM_ID: - ret = hash_get_digest_algorithm_id(&iptr, ilimit, &optr, olimit); + handler = hash_get_digest_algorithm_id; break; case RPC_FUNC_HASH_GET_ALGORITHM: - ret = hash_get_algorithm(&iptr, ilimit, &optr, olimit); + handler = hash_get_algorithm; break; case RPC_FUNC_HASH_INITIALIZE: - ret = hash_initialize(&iptr, ilimit, &optr, olimit); + handler = hash_initialize; break; case RPC_FUNC_HASH_UPDATE: - ret = hash_update(&iptr, ilimit, &optr, olimit); + handler = hash_update; break; case RPC_FUNC_HASH_FINALIZE: - ret = hash_finalize(&iptr, ilimit, &optr, olimit); + handler = hash_finalize; break; case RPC_FUNC_PKEY_LOAD: - ret = pkey_load(&iptr, ilimit, &optr, olimit); + handler = pkey_load; break; - case RPC_FUNC_PKEY_FIND: - ret = pkey_find(&iptr, ilimit, &optr, olimit); + case RPC_FUNC_PKEY_OPEN: + handler = pkey_open; break; case RPC_FUNC_PKEY_GENERATE_RSA: - ret = pkey_generate_rsa(&iptr, ilimit, &optr, olimit); + handler = pkey_generate_rsa; break; case RPC_FUNC_PKEY_GENERATE_EC: - ret = pkey_generate_ec(&iptr, ilimit, &optr, olimit); + handler = pkey_generate_ec; break; case RPC_FUNC_PKEY_CLOSE: - ret = pkey_close(&iptr, ilimit, &optr, olimit); + handler = pkey_close; break; case RPC_FUNC_PKEY_DELETE: - ret = pkey_delete(&iptr, ilimit, &optr, olimit); + handler = pkey_delete; break; case RPC_FUNC_PKEY_GET_KEY_TYPE: - ret = pkey_get_key_type(&iptr, ilimit, &optr, olimit); + handler = pkey_get_key_type; + break; + case RPC_FUNC_PKEY_GET_KEY_CURVE: + handler = pkey_get_key_curve; break; case RPC_FUNC_PKEY_GET_KEY_FLAGS: - ret = pkey_get_key_flags(&iptr, ilimit, &optr, olimit); + handler = pkey_get_key_flags; break; case RPC_FUNC_PKEY_GET_PUBLIC_KEY_LEN: - ret = pkey_get_public_key_len(&iptr, ilimit, &optr, olimit); + handler = pkey_get_public_key_len; break; case RPC_FUNC_PKEY_GET_PUBLIC_KEY: - ret = pkey_get_public_key(&iptr, ilimit, &optr, olimit); + handler = pkey_get_public_key; break; case RPC_FUNC_PKEY_SIGN: - ret = pkey_remote_sign(&iptr, ilimit, &optr, olimit); + handler = pkey_sign; break; case RPC_FUNC_PKEY_VERIFY: - ret = pkey_remote_verify(&iptr, ilimit, &optr, olimit); + handler = pkey_verify; break; - case RPC_FUNC_PKEY_LIST: - ret = pkey_list(&iptr, ilimit, &optr, olimit); + case RPC_FUNC_PKEY_MATCH: + handler = pkey_match; break; - case RPC_FUNC_PKEY_RENAME: - ret = pkey_rename(&iptr, ilimit, &optr, olimit); + case RPC_FUNC_PKEY_SET_ATTRIBUTES: + handler = pkey_set_attributes; break; - default: - ret = HAL_ERROR_RPC_BAD_FUNCTION; + case RPC_FUNC_PKEY_GET_ATTRIBUTES: + handler = pkey_get_attributes; break; } + + if (handler) + ret = handler(&iptr, ilimit, &optr, olimit); + else + ret = HAL_ERROR_RPC_BAD_FUNCTION; + /* Encode opcode, client ID, and response code at the beginning of the payload */ *olen = optr - obuf; optr = obuf; @@ -788,12 +937,26 @@ const hal_rpc_pkey_dispatch_t *hal_rpc_pkey_dispatch = &hal_rpc_local_pkey_dispa hal_error_t hal_rpc_server_init(void) { - return hal_rpc_server_transport_init(); + hal_error_t err; + + if ((err = hal_ks_init(hal_ks_volatile_driver, 1)) != HAL_OK || + (err = hal_ks_init(hal_ks_token_driver, 1)) != HAL_OK || + (err = hal_rpc_server_transport_init()) != HAL_OK) + return err; + + return HAL_OK; } hal_error_t hal_rpc_server_close(void) { - return hal_rpc_server_transport_close(); + hal_error_t err; + + if ((err = hal_rpc_server_transport_close()) != HAL_OK || + (err = hal_ks_shutdown(hal_ks_token_driver)) != HAL_OK || + (err = hal_ks_shutdown(hal_ks_volatile_driver)) != HAL_OK) + return err; + + return HAL_OK; } |