/* * ks.c * ---- * Keystore API. This is internal within libhal. * * Authors: Rob Austein * Copyright (c) 2015, NORDUnet A/S All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * - Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * - Neither the name of the NORDUnet nor the names of its contributors may * be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include "hal.h" #include "hal_internal.h" #include "last_gasp_pin_internal.h" #define KEK_LENGTH (bitsToBytes(256)) /* * In "remote" and "mixed" RPC modes we're a software only RPC client * without (direct) access to secure hardware, thus there is no real * point in encrypting keys. As precautions, we (a) warn about this * when configured in one of these modes, and (b) refuse to store any * sort of private keys. */ #define USE_KEK (RPC_CLIENT != RPC_CLIENT_REMOTE && RPC_CLIENT != RPC_CLIENT_MIXED) #if !USE_KEK #warning ks.c compiled without KEK support and will only accept public keys -- this is normal for the host-side build of libhsm #endif static inline int acceptable_key_type(const hal_key_type_t type) { switch (type) { #if USE_KEK case HAL_KEY_TYPE_RSA_PRIVATE: case HAL_KEY_TYPE_EC_PRIVATE: #endif case HAL_KEY_TYPE_RSA_PUBLIC: case HAL_KEY_TYPE_EC_PUBLIC: return 1; default: return 0; } } hal_error_t hal_ks_store(const hal_key_type_t type, const hal_curve_name_t curve, const hal_key_flags_t flags, const uint8_t * const name, const size_t name_len, const uint8_t * const der, const size_t der_len, int *hint) { if (name == NULL || der == NULL || der_len == 0 || !acceptable_key_type(type)) return HAL_ERROR_BAD_ARGUMENTS; if (name_len > HAL_RPC_PKEY_NAME_MAX) return HAL_ERROR_KEY_NAME_TOO_LONG; const hal_ks_keydb_t * const db = hal_ks_get_keydb(); hal_error_t err; int hint_; if (db == NULL) return HAL_ERROR_KEYSTORE_ACCESS; if (hint == NULL) hint = &hint_; *hint = -1; for (int i = 0; i < sizeof(db->keys)/sizeof(*db->keys); i++) { if (!db->keys[i].in_use && *hint < 0) *hint = i; if (db->keys[i].in_use && db->keys[i].type == type && db->keys[i].name_len == name_len && memcmp(db->keys[i].name, name, name_len) == 0) return HAL_ERROR_KEY_NAME_IN_USE; } if (*hint < 0) return HAL_ERROR_NO_KEY_SLOTS_AVAILABLE; hal_ks_key_t k; memset(&k, 0, sizeof(k)); k.der_len = sizeof(k.der); #if USE_KEK uint8_t kek[KEK_LENGTH]; size_t kek_len; if ((err = hal_ks_get_kek(kek, &kek_len, sizeof(kek))) == HAL_OK) err = hal_aes_keywrap(NULL, kek, kek_len, der, der_len, k.der, &k.der_len); memset(kek, 0, sizeof(kek)); if (err != HAL_OK) return err; #else /* USE_KEK */ if (der_len > k.der_len) return HAL_ERROR_RESULT_TOO_LONG; k.der_len = der_len; memcpy(k.der, der, der_len); #endif /* USE_KEK */ assert(name_len <= sizeof(k.name)); memcpy(k.name, name, name_len); k.name_len = name_len; k.type = type; k.curve = curve; k.flags = flags; if ((err = hal_ks_set_keydb(&k, *hint, 0)) != HAL_OK) return err; return HAL_OK; } static int find(const hal_ks_keydb_t * const db, const hal_key_type_t type, const uint8_t * const name, const size_t name_len, int *hint) { assert(db != NULL && name != NULL && acceptable_key_type(type)); if (hint != NULL && *hint >= 0 && *hint < sizeof(db->keys)/sizeof(*db->keys) && db->keys[*hint].in_use && db->keys[*hint].type == type && db->keys[*hint].name_len == name_len && memcmp(db->keys[*hint].name, name, name_len) == 0) return 1; for (int i = 0; i < sizeof(db->keys)/sizeof(*db->keys); i++) { if (!db->keys[i].in_use || (hint != NULL && i == *hint) || db->keys[i].type != type || db->keys[i].name_len != name_len || memcmp(db->keys[i].name, name, name_len) != 0) continue; if (hint != NULL) *hint = i; return 1; } return 0; } hal_error_t hal_ks_exists(const hal_key_type_t type, const uint8_t * const name, const size_t name_len, int *hint) { if (name == NULL || !acceptable_key_type(type)) return HAL_ERROR_BAD_ARGUMENTS; const hal_ks_keydb_t * const db = hal_ks_get_keydb(); if (db == NULL) return HAL_ERROR_KEYSTORE_ACCESS; if (find(db, type, name, name_len, hint)) return HAL_OK; else return HAL_ERROR_KEY_NOT_FOUND; } hal_error_t hal_ks_fetch(const hal_key_type_t type, const uint8_t * const name, const size_t name_len, hal_curve_name_t *curve, hal_key_flags_t *flags, uint8_t *der, size_t *der_len, const size_t der_max, int *hint) { if (name == NULL || !acceptable_key_type(type)) return HAL_ERROR_BAD_ARGUMENTS; const hal_ks_keydb_t * const db = hal_ks_get_keydb(); int hint_ = -1; if (db == NULL) return HAL_ERROR_KEYSTORE_ACCESS; if (hint == NULL) hint = &hint_; if (!find(db, type, name, name_len, hint)) return HAL_ERROR_KEY_NOT_FOUND; const hal_ks_key_t * const k = &db->keys[*hint]; if (curve != NULL) *curve = k->curve; if (flags != NULL) *flags = k->flags; if (der == NULL && der_len != NULL) *der_len = k->der_len; if (der != NULL) { #if USE_KEK uint8_t kek[KEK_LENGTH]; size_t kek_len, der_len_; hal_error_t err; if (der_len == NULL) der_len = &der_len_; *der_len = der_max; if ((err = hal_ks_get_kek(kek, &kek_len, sizeof(kek))) == HAL_OK) err = hal_aes_keyunwrap(NULL, kek, kek_len, k->der, k->der_len, der, der_len); memset(kek, 0, sizeof(kek)); if (err != HAL_OK) return err; #else /* USE_KEK */ if (k->der_len > der_max) return HAL_ERROR_RESULT_TOO_LONG; if (der_len != NULL) *der_len = k->der_len; memcpy(der, k->der, k->der_len); #endif /* USE_KEK */ } return HAL_OK; } hal_error_t hal_ks_delete(const hal_key_type_t type, const uint8_t * const name, const size_t name_len, int *hint) { if (name == NULL || !acceptable_key_type(type)) return HAL_ERROR_BAD_ARGUMENTS; const hal_ks_keydb_t * const db = hal_ks_get_keydb(); int hint_ = -1; if (db == NULL) return HAL_ERROR_KEYSTORE_ACCESS; if (hint == NULL) hint = &hint_; if (!find(db, type, name, name_len, hint)) return HAL_ERROR_KEY_NOT_FOUND; return hal_ks_del_keydb(*hint); } hal_error_t hal_ks_rename(const hal_key_type_t type, const uint8_t * const old_name, const size_t old_name_len, const uint8_t * const new_name, const size_t new_name_len, int *hint) { if (old_name == NULL || new_name == NULL || !acceptable_key_type(type)) return HAL_ERROR_BAD_ARGUMENTS; if (new_name_len > HAL_RPC_PKEY_NAME_MAX) return HAL_ERROR_KEY_NAME_TOO_LONG; const hal_ks_keydb_t * const db = hal_ks_get_keydb(); int hint_ = -1; if (db == NULL) return HAL_ERROR_KEYSTORE_ACCESS; if (find(db, type, new_name, new_name_len, NULL)) return HAL_ERROR_KEY_NAME_IN_USE; if (hint == NULL) hint = &hint_; if (!find(db, type, old_name, old_name_len, hint)) return HAL_ERROR_KEY_NOT_FOUND; hal_ks_key_t k = db->keys[*hint]; assert(new_name_len <= sizeof(k.name)); memcpy(k.name, new_name, new_name_len); k.name_len = new_name_len; return hal_ks_set_keydb(&k, *hint, 1); } hal_error_t hal_ks_list(hal_pkey_info_t *result, unsigned *result_len, const unsigned result_max) { if (result == NULL || result_len == NULL) return HAL_ERROR_BAD_ARGUMENTS; const hal_ks_keydb_t * const db = hal_ks_get_keydb(); if (db == NULL) return HAL_ERROR_KEYSTORE_ACCESS; *result_len = 0; for (int i = 0; i < sizeof(db->keys)/sizeof(*db->keys); i++) { if (!db->keys[i].in_use) continue; if (*result_len == result_max) return HAL_ERROR_RESULT_TOO_LONG; result[*result_len].type = db->keys[i].type; result[*result_len].curve = db->keys[i].curve; result[*result_len].flags = db->keys[i].flags; result[*result_len].name_len = db->keys[i].name_len; memcpy(result[*result_len].name, db->keys[i].name, db->keys[i].name_len); ++ *result_len; } return HAL_OK; } hal_error_t hal_ks_get_pin(const hal_user_t user, const hal_ks_pin_t **pin) { if (pin == NULL) return HAL_ERROR_BAD_ARGUMENTS; const hal_ks_keydb_t * const db = hal_ks_get_keydb(); if (db == NULL) return HAL_ERROR_KEYSTORE_ACCESS; switch (user) { case HAL_USER_WHEEL: *pin = &db->wheel_pin; break; case HAL_USER_SO: *pin = &db->so_pin; break; case HAL_USER_NORMAL: *pin = &db->user_pin; break; default: return HAL_ERROR_BAD_ARGUMENTS; } #warning Need better "Have we been initialized yet?" test /* * If we were looking for the WHEEL PIN and it appears to be * completely unset, return the compiled-in last-gasp PIN. This is * a terrible answer, but we need some kind of bootstrapping * mechanism. Feel free to suggest something better. * * We probably need some more general "have we been initialized?" * state somewhere, and might want to refuse to do things like * storing keys until we've been initialized and the appropriate * PINs have been set. * * Just to make things more fun, some drivers return all zeros for * "this has never been set", some return all ones to indicate the * same thing. REALLY need a flag somewhere. */ uint8_t u00 = 0x00, uFF = 0xFF; for (int i = 0; i < sizeof((*pin)->pin); i++) { u00 |= (*pin)->pin[i]; uFF &= (*pin)->pin[i]; } for (int i = 0; i < sizeof((*pin)->salt); i++) { u00 |= (*pin)->salt[i]; uFF &= (*pin)->salt[i]; } if (user == HAL_USER_WHEEL && ((u00 == 0x00 && (*pin)->iterations == 0x00000000) || (uFF == 0xFF && (*pin)->iterations == 0xFFFFFFFF))) *pin = &hal_last_gasp_pin; return HAL_OK; } /* * Local variables: * indent-tabs-mode: nil * End: */ 5' href='#n255'>255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 
/*
 * rpc_server.c
 * ------------
 * Remote procedure call server-side private API implementation.
 *
 * Copyright (c) 2016, NORDUnet A/S All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 * - Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 *
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * - Neither the name of the NORDUnet nor the names of its contributors may
 *   be used to endorse or promote products derived from this software
 *   without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "hal.h"
#include "hal_internal.h"
#include "xdr_internal.h"

/*
 * RPC calls.
 */

#define check(op) if ((ret = (op)) != HAL_OK) return ret;

#define pad(n) (((n) + 3) & ~3)

static hal_error_t get_version(const uint8_t **iptr, const uint8_t * const ilimit,
                               uint8_t **optr, const uint8_t * const olimit)
{
    hal_client_handle_t client __attribute__((unused));
    uint32_t version;
    hal_error_t ret;

    check(hal_xdr_decode_int(iptr, ilimit, &client.handle));

    /* call the local function */
    ret = hal_rpc_local_misc_dispatch.get_version(&version);
    if (ret == HAL_OK)
        check(hal_xdr_encode_int(optr, olimit, version));

    return ret;
}

static hal_error_t get_random(const uint8_t **iptr, const uint8_t * const ilimit,
                              uint8_t **optr, const uint8_t * const olimit)
{
    hal_client_handle_t client __attribute__((unused));
    uint32_t length;
    hal_error_t ret;

    check(hal_xdr_decode_int(iptr, ilimit, &client.handle));
    check(hal_xdr_decode_int(iptr, ilimit, &length));
    /* sanity check length */
    if (length == 0 || length > olimit - *optr - 4)
        return HAL_ERROR_RPC_PACKET_OVERFLOW;

    /* 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);
    if (ret == HAL_OK)
        *optr += pad(length);
    else
        /* don't return data if error */
        *optr -= 4;

    return ret;
}

static hal_error_t set_pin(const uint8_t **iptr, const uint8_t * const ilimit,
                           uint8_t **optr, const uint8_t * const olimit)
{
    hal_client_handle_t client;
    uint32_t user;
    const uint8_t *pin;
    uint32_t pin_len;
    hal_error_t ret;

    check(hal_xdr_decode_int(iptr, ilimit, &client.handle));
    check(hal_xdr_decode_int(iptr, ilimit, &user));
    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);
    return ret;
}

static hal_error_t login(const uint8_t **iptr, const uint8_t * const ilimit,
                         uint8_t **optr, const uint8_t * const olimit)
{
    hal_client_handle_t client;
    uint32_t user;
    const uint8_t *pin;
    uint32_t pin_len;
    hal_error_t ret;

    check(hal_xdr_decode_int(iptr, ilimit, &client.handle));
    check(hal_xdr_decode_int(iptr, ilimit, &user));
    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);
    return ret;
}

static hal_error_t logout(const uint8_t **iptr, const uint8_t * const ilimit,
                          uint8_t **optr, const uint8_t * const olimit)
{
    hal_client_handle_t client;
    hal_error_t ret;

    check(hal_xdr_decode_int(iptr, ilimit, &client.handle));

    /* call the local function */
    ret = hal_rpc_local_misc_dispatch.logout(client);
    return ret;
}

static hal_error_t logout_all(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_error_t ret;

    check(hal_xdr_decode_int(iptr, ilimit, &client.handle));

    /* call the local function */
    ret = hal_rpc_local_misc_dispatch.logout_all();
    return ret;
}

static hal_error_t is_logged_in(const uint8_t **iptr, const uint8_t * const ilimit,
                                uint8_t **optr, const uint8_t * const olimit)
{
    hal_client_handle_t client;
    uint32_t user;
    hal_error_t ret;

    check(hal_xdr_decode_int(iptr, ilimit, &client.handle));
    check(hal_xdr_decode_int(iptr, ilimit, &user));

    /* call the local function */
    ret = hal_rpc_local_misc_dispatch.is_logged_in(client, user);
    return ret;
}

static hal_error_t hash_get_digest_len(const uint8_t **iptr, const uint8_t * const ilimit,
                                       uint8_t **optr, const uint8_t * const olimit)
{
    hal_client_handle_t client __attribute__((unused));
    uint32_t alg;
    size_t length;
    hal_error_t ret;

    check(hal_xdr_decode_int(iptr, ilimit, &client.handle));
    check(hal_xdr_decode_int(iptr, ilimit, &alg));

    /* call the local function */
    ret = hal_rpc_local_hash_dispatch.get_digest_length(alg, &length);
    if (ret == HAL_OK)
        check(hal_xdr_encode_int(optr, olimit, length));
    return ret;
}

static hal_error_t hash_get_digest_algorithm_id(const uint8_t **iptr, const uint8_t * const ilimit,
                                                uint8_t **optr, const uint8_t * const olimit)
{
    hal_client_handle_t client __attribute__((unused));
    uint32_t alg;
    size_t len;
    uint32_t len_max;
    uint8_t *optr_orig = *optr;
    hal_error_t ret;

    check(hal_xdr_decode_int(iptr, ilimit, &client.handle));
    check(hal_xdr_decode_int(iptr, ilimit, &alg));
    check(hal_xdr_decode_int(iptr, ilimit, &len_max));
    /* sanity check len_max */
    if (len_max > olimit - *optr - 4)
        return HAL_ERROR_RPC_PACKET_OVERFLOW;

    /* 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);
    if (ret == HAL_OK) {
        *optr = optr_orig;
        check(hal_xdr_encode_int(optr, olimit, len));
        *optr += pad(len);
    }
    else {
        /* don't return data if error */
        *optr = optr_orig;
    }
    return ret;
}

static hal_error_t hash_get_algorithm(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_hash_handle_t hash;
    hal_digest_algorithm_t alg;
    hal_error_t ret;

    check(hal_xdr_decode_int(iptr, ilimit, &client.handle));
    check(hal_xdr_decode_int(iptr, ilimit, &hash.handle));

    /* call the local function */
    ret = hal_rpc_local_hash_dispatch.get_algorithm(hash, &alg);
    if (ret == HAL_OK)
        check(hal_xdr_encode_int(optr, olimit, alg));
    return ret;
}

static hal_error_t hash_initialize(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_hash_handle_t hash;
    uint32_t alg;
    const uint8_t *key;
    uint32_t key_len;
    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, &alg));
    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);
    if (ret == HAL_OK)
        check(hal_xdr_encode_int(optr, olimit, hash.handle));
    return ret;
}

static hal_error_t hash_update(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_hash_handle_t hash;
    const uint8_t *data;
    uint32_t length;
    hal_error_t ret;

    check(hal_xdr_decode_int(iptr, ilimit, &client.handle));
    check(hal_xdr_decode_int(iptr, ilimit, &hash.handle));
    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);
    return ret;
}

static hal_error_t hash_finalize(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_hash_handle_t hash;
    uint32_t length;
    hal_error_t ret;

    check(hal_xdr_decode_int(iptr, ilimit, &client.handle));
    check(hal_xdr_decode_int(iptr, ilimit, &hash.handle));
    check(hal_xdr_decode_int(iptr, ilimit, &length));
    /* sanity check length */
    if (length == 0 || length > olimit - *optr - 4)
        return HAL_ERROR_RPC_PACKET_OVERFLOW;

    /* 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);
    if (ret == HAL_OK)
        *optr += pad(length);
    else
        /* don't return data if error */
        *optr -= 4;
    return ret;
}

static hal_error_t pkey_load(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;
    uint32_t curve;
    const uint8_t *name, *der;
    uint32_t name_len, der_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_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));
    return ret;
}

static hal_error_t pkey_find(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;
    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_int(iptr, ilimit, &flags));

    /* call the local function */
    ret = hal_rpc_local_pkey_dispatch.find(client, session, &pkey, type, name, name_len, flags);
    if (ret == HAL_OK)
        check(hal_xdr_encode_int(optr, olimit, pkey.handle));
    return ret;
}

static hal_error_t pkey_generate_rsa(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;
    const uint8_t *name;
    uint32_t name_len;
    uint32_t key_len;
    const uint8_t *exp;
    uint32_t exp_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_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));
    return ret;
}

static hal_error_t pkey_generate_ec(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;
    const uint8_t *name;
    uint32_t name_len;
    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));
    return ret;
}

static hal_error_t pkey_close(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;
    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.close(pkey);
    return ret;
}

static hal_error_t pkey_delete(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;
    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.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)
{
    hal_client_handle_t client __attribute__((unused));
    hal_pkey_handle_t pkey;
    const uint8_t *name;
    uint32_t name_len;
    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);
    return ret;
}

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;
    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));

    /* call the local function */
    ret = hal_rpc_local_pkey_dispatch.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_flags(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;
    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, &pkey.handle));

    /* call the local function */
    ret = hal_rpc_local_pkey_dispatch.get_key_flags(pkey, &flags);
    if (ret == HAL_OK)
        check(hal_xdr_encode_int(optr, olimit, flags));
    return ret;
}

static hal_error_t pkey_get_public_key_len(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;
    size_t len;
    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 */
    len = hal_rpc_local_pkey_dispatch.get_public_key_len(pkey);
    check(hal_xdr_encode_int(optr, olimit, len));
    return HAL_OK;
}

static hal_error_t pkey_get_public_key(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;
    size_t len;
    uint32_t len_max;
    uint8_t *optr_orig = *optr;
    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_int(iptr, ilimit, &len_max));
    /* sanity check len_max */
    if (len_max > olimit - *optr - 4)
        return HAL_ERROR_RPC_PACKET_OVERFLOW;

    /* 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);
    if (ret == HAL_OK) {
        *optr = optr_orig;
        check(hal_xdr_encode_int(optr, olimit, len));
        *optr += pad(len);
    }
    else {
        /* don't return data if error */
        *optr = optr_orig;
    }
    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)
{
    hal_client_handle_t client __attribute__((unused));
    hal_session_handle_t session;
    hal_pkey_handle_t pkey;
    hal_hash_handle_t hash;
    const uint8_t *input;
    uint32_t input_len;
    uint32_t sig_max;
    size_t sig_len;
    uint8_t *optr_orig = *optr;
    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_int(iptr, ilimit, &sig_max));
    /* sanity check sig_max */
    if (sig_max > olimit - *optr - 4)
        return HAL_ERROR_RPC_PACKET_OVERFLOW;

    /* 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);
    *optr = optr_orig;
    if (ret == HAL_OK) {
        check(hal_xdr_encode_int(optr, olimit, sig_len));
        *optr += pad(sig_len);
    }
    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)
{
    hal_client_handle_t client __attribute__((unused));
    hal_session_handle_t session;
    hal_pkey_handle_t pkey;
    hal_hash_handle_t hash;
    const uint8_t *input;
    uint32_t input_len;
    const uint8_t *sig;
    uint32_t sig_len;
    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);
    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)
{
    uint8_t *optr_orig = *optr;
    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;
    return ret;
}


static hal_error_t pkey_list(const uint8_t **iptr, const uint8_t * const ilimit,
                             uint8_t **optr, const uint8_t * const olimit)
{
    hal_client_handle_t client __attribute__((unused));
    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));

    hal_pkey_info_t result[result_max];
    unsigned result_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;
                break;
            }
        }
    }
    return ret;
}

void hal_rpc_server_dispatch(const uint8_t * const ibuf, const size_t ilen,
                             uint8_t * const obuf, size_t * const olen)
{
    const uint8_t * iptr = ibuf;
    const uint8_t * const ilimit = ibuf + ilen;
    uint8_t * optr = obuf + 12;	/* reserve space for opcode, client, and response code */
    const uint8_t * const olimit = obuf + *olen;
    uint32_t rpc_func_num;
    uint32_t client_handle;
    hal_error_t ret;

    hal_xdr_decode_int(&iptr, ilimit, &rpc_func_num);
    hal_xdr_decode_int(&iptr, ilimit, &client_handle);
    hal_xdr_undecode_int(&iptr);
    switch (rpc_func_num) {
    case RPC_FUNC_GET_VERSION:
        ret = get_version(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_GET_RANDOM:
        ret = get_random(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_SET_PIN:
        ret = set_pin(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_LOGIN:
        ret = login(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_LOGOUT:
        ret = logout(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_LOGOUT_ALL:
        ret = logout_all(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_IS_LOGGED_IN:
        ret = is_logged_in(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_HASH_GET_DIGEST_LEN:
        ret = hash_get_digest_len(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_HASH_GET_DIGEST_ALGORITHM_ID:
        ret = hash_get_digest_algorithm_id(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_HASH_GET_ALGORITHM:
        ret = hash_get_algorithm(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_HASH_INITIALIZE:
        ret = hash_initialize(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_HASH_UPDATE:
        ret = hash_update(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_HASH_FINALIZE:
        ret = hash_finalize(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_PKEY_LOAD:
        ret = pkey_load(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_PKEY_FIND:
        ret = pkey_find(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_PKEY_GENERATE_RSA:
        ret = pkey_generate_rsa(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_PKEY_GENERATE_EC:
        ret = pkey_generate_ec(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_PKEY_CLOSE:
        ret = pkey_close(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_PKEY_DELETE:
        ret = pkey_delete(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_PKEY_GET_KEY_TYPE:
        ret = pkey_get_key_type(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_PKEY_GET_KEY_FLAGS:
        ret = pkey_get_key_flags(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_PKEY_GET_PUBLIC_KEY_LEN:
        ret = pkey_get_public_key_len(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_PKEY_GET_PUBLIC_KEY:
        ret = pkey_get_public_key(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_PKEY_REMOTE_SIGN:
        ret = pkey_remote_sign(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_PKEY_REMOTE_VERIFY:
        ret = pkey_remote_verify(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_PKEY_LIST:
        ret = pkey_list(&iptr, ilimit, &optr, olimit);
        break;
    case RPC_FUNC_PKEY_RENAME:
        ret = pkey_rename(&iptr, ilimit, &optr, olimit);
        break;
    default:
        ret = HAL_ERROR_RPC_BAD_FUNCTION;
        break;
    }
    /* Encode opcode, client ID, and response code at the beginning of the payload */
    *olen = optr - obuf;
    optr = obuf;
    hal_xdr_encode_int(&optr, olimit, rpc_func_num);
    hal_xdr_encode_int(&optr, olimit, client_handle);
    hal_xdr_encode_int(&optr, olimit, ret);
}

#define interrupt 0

static uint8_t inbuf[HAL_RPC_MAX_PKT_SIZE], outbuf[HAL_RPC_MAX_PKT_SIZE];

void hal_rpc_server_main(void)
{
    size_t ilen, olen;
    void *opaque;
    hal_error_t ret;

    while (!interrupt) {
        ilen = sizeof(inbuf);
        ret = hal_rpc_recvfrom(inbuf, &ilen, &opaque);
        if (ret == HAL_OK) {
            olen = sizeof(outbuf);
            hal_rpc_server_dispatch(inbuf, ilen, outbuf, &olen);
            hal_rpc_sendto(outbuf, olen, opaque);
        }
    }
}

/*
 * Dispatch vectors.
 */

#if RPC_CLIENT == RPC_CLIENT_LOCAL
const hal_rpc_misc_dispatch_t *hal_rpc_misc_dispatch = &hal_rpc_local_misc_dispatch;
const hal_rpc_hash_dispatch_t *hal_rpc_hash_dispatch = &hal_rpc_local_hash_dispatch;
const hal_rpc_pkey_dispatch_t *hal_rpc_pkey_dispatch = &hal_rpc_local_pkey_dispatch;
#endif

hal_error_t hal_rpc_server_init(void)
{
    return hal_rpc_server_transport_init();
}

hal_error_t hal_rpc_server_close(void)
{
    return hal_rpc_server_transport_close();
}


/*
 * Local variables:
 * indent-tabs-mode: nil
 * End:
 */
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-06 03:12:15 +0000