/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 * Tests:
 * generic:
 * - no session / invalid session
 * - closed session
 *
 * hwkey:
 * - derive twice to same result
 * - derive different, different result
 * - keyslot, invalid slot
 *
 */

#define TLOG_TAG "hwcrypto_unittest"

#include <math.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#include <interface/hwkey/hwkey.h>
#include <lib/hwkey/hwkey.h>
#include <trusty_unittest.h>
#include <uapi/err.h>

#define RPMB_STORAGE_AUTH_KEY_ID "com.android.trusty.storage_auth.rpmb"
#define HWCRYPTO_UNITTEST_KEYBOX_ID "com.android.trusty.hwcrypto.unittest.key32"
#define HWCRYPTO_UNITTEST_DERIVED_KEYBOX_ID \
    "com.android.trusty.hwcrypto.unittest.derived_key32"
#define HWCRYPTO_UNITTEST_OPAQUE_HANDLE_ID \
    "com.android.trusty.hwcrypto.unittest.opaque_handle"
#define HWCRYPTO_UNITTEST_OPAQUE_HANDLE2_ID \
    "com.android.trusty.hwcrypto.unittest.opaque_handle2"
#define HWCRYPTO_UNITTEST_OPAQUE_HANDLE_NOACCESS_ID \
    "com.android.trusty.hwcrypto.unittest.opaque_handle_noaccess"
#define HWCRYPTO_UNITTEST_OPAQUE_DERIVED_ID \
    "com.android.trusty.hwcrypto.unittest.opaque_derived"

#define STORAGE_AUTH_KEY_SIZE 32

static const uint8_t UNITTEST_KEYSLOT[] = "unittestkeyslotunittestkeyslotun";
static const uint8_t UNITTEST_DERIVED_KEYSLOT[] =
        "unittestderivedkeyslotunittestde";
#if WITH_HWCRYPTO_UNITTEST
#define DISABLED_WITHOUT_HWCRYPTO_UNITTEST(name) name
#else
#pragma message                                                                          \
        "hwcrypto-unittest is built with the WITH_HWCRYPTO_UNITTEST define not enabled." \
        "Hwkey tests will not test anything."
#define DISABLED_WITHOUT_HWCRYPTO_UNITTEST(name) DISABLED_##name
#endif

static bool keys_are_sufficiently_distinct(uint8_t* buf1,
                                           size_t buf1_len,
                                           uint8_t* buf2,
                                           size_t buf2_len) {
    size_t differing_bytes = 0;
    for (size_t i = 0; i < MIN(buf1_len, buf2_len); ++i) {
        if (buf1[i] ^ buf2[i]) {
            differing_bytes++;
        }
    }
    return MIN(buf1_len, buf2_len) - differing_bytes <= 4;
}

/*
 * Implement this hook for device specific hwkey tests
 */
__WEAK void run_device_hwcrypto_unittest(void) {}

TEST(hwcrypto, device_hwcrypto_unittest) {
    run_device_hwcrypto_unittest();
}

typedef struct hwkey {
    hwkey_session_t hwkey_session;
} hwkey_t;

TEST_F_SETUP(hwkey) {
    int rc;

    _state->hwkey_session = INVALID_IPC_HANDLE;
    rc = hwkey_open();
    ASSERT_GE(rc, 0);
    _state->hwkey_session = (hwkey_session_t)rc;

test_abort:;
}

TEST_F_TEARDOWN(hwkey) {
    close(_state->hwkey_session);
}

TEST_F(hwkey, generic_invalid_session) {
    const uint8_t src_data[] = "thirtytwo-bytes-of-nonsense-data";
    static const size_t size = sizeof(src_data);
    uint8_t dest[sizeof(src_data)];

    hwkey_session_t invalid = INVALID_IPC_HANDLE;
    uint32_t kdf_version = HWKEY_KDF_VERSION_BEST;

    // should fail immediately
    long rc = hwkey_derive(invalid, &kdf_version, src_data, dest, size);
    EXPECT_EQ(ERR_BAD_HANDLE, rc, "generic - bad handle");
}

TEST_F(hwkey, generic_closed_session) {
    static const uint8_t src_data[] = "thirtytwo-bytes-of-nonsense-data";
    static const uint32_t size = sizeof(src_data);
    uint8_t dest[sizeof(src_data)];
    uint32_t kdf_version = HWKEY_KDF_VERSION_BEST;

    long rc = hwkey_open();
    EXPECT_GE(rc, 0, "generic - open");

    hwkey_session_t session = (hwkey_session_t)rc;
    hwkey_close(session);

    // should fail immediately
    rc = hwkey_derive(session, &kdf_version, src_data, dest, size);
    EXPECT_EQ(ERR_NOT_FOUND, rc, "generic - closed handle");
}

TEST_F(hwkey, derive_repeatable) {
    const uint8_t src_data[] = "thirtytwo-bytes-of-nonsense-data";
    uint8_t dest[32];
    uint8_t dest2[sizeof(dest)];
    static const size_t size = sizeof(dest);
    uint32_t kdf_version = HWKEY_KDF_VERSION_BEST;
    struct hwkey_versioned_key_options versioned_args = {
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_RUNNING_VERSION,
            .os_rollback_version = 0,
            .context = src_data,
            .context_len = size,
    };

    memset(dest, 0, size);
    memset(dest2, 0, size);

    /* derive key once */
    long rc = hwkey_derive(_state->hwkey_session, &kdf_version, src_data, dest,
                           size);
    EXPECT_EQ(NO_ERROR, rc, "derive repeatable - initial derivation");
    EXPECT_NE(HWKEY_KDF_VERSION_BEST, kdf_version,
              "derive repeatable - kdf version");

    /* derive key again */
    rc = hwkey_derive(_state->hwkey_session, &kdf_version, src_data, dest2,
                      size);
    EXPECT_EQ(NO_ERROR, rc, "derive repeatable - second derivation");

    /* ensure they are the same */
    rc = memcmp(dest, dest2, size);
    EXPECT_EQ(0, rc, "derive repeatable - equal");
    rc = memcmp(dest, src_data, size);
    EXPECT_NE(0, rc, "derive repeatable - same as seed");

    /* derive the same key using the versioned API fallback */
    memset(dest2, 0, size);
    versioned_args.key = dest2;
    versioned_args.key_len = size;
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc, "derive repeatable - versioned API");

    /* ensure they are the same */
    rc = memcmp(dest, dest2, size);
    EXPECT_EQ(0, rc, "derive repeatable - equal");

    /* ensure that we don't derive the same key if deriving a shared key */
    memset(dest2, 0, size);
    versioned_args.shared_key = true;
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc, "derive repeatable - versioned API");

    rc = memcmp(dest, dest2, size);
    EXPECT_NE(0, rc, "derive repeatable - equal");
    EXPECT_EQ(true, keys_are_sufficiently_distinct(dest, size, dest2, size),
              "derived keys share too many bytes");

    /*
     * ensure that we don't derive the same key if deriving a versioned,
     * device-unique key
     */
    memset(dest2, 0, size);
    versioned_args.shared_key = false;
    versioned_args.os_rollback_version = HWKEY_ROLLBACK_VERSION_CURRENT;
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc, "derive repeatable - versioned API");

    rc = memcmp(dest, dest2, size);
    if (versioned_args.os_rollback_version > 0) {
        EXPECT_NE(0, rc, "derive repeatable - equal");
        EXPECT_EQ(true, keys_are_sufficiently_distinct(dest, size, dest2, size),
                  "derived keys share too many bytes");
    } else {
        EXPECT_EQ(0, rc, "derive repeatable - not equal");
    }
}

TEST_F(hwkey, derive_repeatable_versioned) {
    const uint8_t src_data[] = "thirtytwo-bytes-of-nonsense-data";
    uint8_t dest[128];
    uint8_t dest2[128];
    static const size_t key_len = sizeof(dest);
    long rc;
    struct hwkey_versioned_key_options versioned_args = {
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_RUNNING_VERSION,
            .os_rollback_version = HWKEY_ROLLBACK_VERSION_CURRENT,
            .context = src_data,
            .context_len = sizeof(src_data),
            .key_len = key_len,
    };

    memset(dest, 0, key_len);
    memset(dest2, 0, key_len);

    versioned_args.key = dest;
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc, "derive repeatable versioned - initial derivation");
    EXPECT_NE(HWKEY_KDF_VERSION_BEST, versioned_args.kdf_version,
              "derive repeatable versioned - kdf version");

    rc = memcmp(dest, dest2, key_len);
    EXPECT_NE(0, rc, "derive repeatable versioned - not zeroed");
    EXPECT_NE(versioned_args.os_rollback_version,
              HWKEY_ROLLBACK_VERSION_CURRENT,
              "derive repeatable current version");

    memset(dest2, 0, key_len);
    versioned_args.key = dest2;
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc, "derive repeatable versioned - second derivation");

    /* ensure they are the same */
    rc = memcmp(dest, dest2, key_len);
    EXPECT_EQ(0, rc, "derive repeatable versioned - equal");
    rc = memcmp(dest, src_data, sizeof(src_data));
    EXPECT_NE(0, rc, "derive repeatable versioned - same as seed");

    /* repeat for shared keys */
    versioned_args.shared_key = true;
    memset(dest, 0, key_len);
    memset(dest2, 0, key_len);

    versioned_args.key = dest;
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc, "derive repeatable versioned - initial derivation");
    EXPECT_NE(HWKEY_KDF_VERSION_BEST, versioned_args.kdf_version,
              "derive repeatable versioned - kdf version");

    rc = memcmp(dest, dest2, key_len);
    EXPECT_NE(0, rc, "derive repeatable versioned - not zeroed");

    memset(dest2, 0, key_len);
    versioned_args.key = dest2;
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc, "derive repeatable versioned - second derivation");

    /* ensure they are the same */
    rc = memcmp(dest, dest2, key_len);
    EXPECT_EQ(0, rc, "derive repeatable versioned - equal");
    rc = memcmp(dest, src_data, sizeof(src_data));
    EXPECT_NE(0, rc, "derive repeatable versioned - same as seed");
}

TEST_F(hwkey, derive_different) {
    const uint8_t src_data[] = "thirtytwo-bytes-of-nonsense-data";
    const uint8_t src_data2[] = "thirtytwo-byt3s-of-nons3ns3-data";

    uint8_t dest[32];
    uint8_t dest2[sizeof(dest)];
    static const uint32_t size = sizeof(dest);
    uint32_t kdf_version = HWKEY_KDF_VERSION_BEST;

    memset(dest, 0, size);
    memset(dest2, 0, size);

    /* derive key once */
    long rc = hwkey_derive(_state->hwkey_session, &kdf_version, src_data, dest,
                           size);
    EXPECT_EQ(NO_ERROR, rc, "derive not repeatable - initial derivation");
    EXPECT_NE(HWKEY_KDF_VERSION_BEST, kdf_version,
              "derive not repeatable - kdf version");

    /* derive key again, with different source data */
    rc = hwkey_derive(_state->hwkey_session, &kdf_version, src_data2, dest2,
                      size);
    EXPECT_EQ(NO_ERROR, rc, "derive not repeatable - second derivation");

    /* ensure they are not the same */
    rc = memcmp(dest, dest2, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal");
    rc = memcmp(dest, src_data, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal to source");
    rc = memcmp(dest2, src_data2, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal to source");

    EXPECT_EQ(true, keys_are_sufficiently_distinct(dest, size, dest2, size),
              "derived keys share too many bytes");
}

TEST_F(hwkey, derive_different_versioned) {
    const uint8_t src_data[] = "thirtytwo-bytes-of-nonsense-data";
    const uint8_t src_data2[] = "thirtytwo-byt3s-of-nons3ns3-data";

    uint8_t dest[32];
    uint8_t dest2[sizeof(dest)];
    uint8_t dest_shared[sizeof(dest)];
    uint8_t dest_shared2[sizeof(dest)];
    static const uint32_t size = sizeof(dest);
    long rc;
    struct hwkey_versioned_key_options versioned_args;

    memset(dest, 0, size);
    memset(dest2, 0, size);
    memset(dest_shared, 0, size);
    memset(dest_shared2, 0, size);

    versioned_args = (struct hwkey_versioned_key_options){
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_RUNNING_VERSION,
            .os_rollback_version = HWKEY_ROLLBACK_VERSION_CURRENT,
            .context = src_data,
            .context_len = sizeof(src_data),
            .shared_key = false,
            .key = dest,
            .key_len = sizeof(dest),
    };
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc,
              "derive not repeatable versioned - initial derivation");
    EXPECT_NE(HWKEY_KDF_VERSION_BEST, versioned_args.kdf_version,
              "derive not repeatable versioned - kdf version");

    /* derive with the same input but an older OS version */
    if (versioned_args.os_rollback_version >= 1) {
        versioned_args = (struct hwkey_versioned_key_options){
                .kdf_version = HWKEY_KDF_VERSION_BEST,
                .rollback_version_source = HWKEY_ROLLBACK_RUNNING_VERSION,
                .os_rollback_version = versioned_args.os_rollback_version - 1,
                .context = src_data,
                .context_len = sizeof(src_data),
                .shared_key = false,
                .key = dest2,
                .key_len = sizeof(dest2),
        };
        rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
        EXPECT_EQ(NO_ERROR, rc,
                  "derive not repeatable versioned - second derivation");

        /* ensure they are not the same */
        rc = memcmp(dest, dest2, size);
        EXPECT_NE(0, rc, "derive not repeatable - equal");
        rc = memcmp(dest, src_data, size);
        EXPECT_NE(0, rc, "derive not repeatable - equal to source");
        rc = memcmp(dest2, src_data2, size);
        EXPECT_NE(0, rc, "derive not repeatable - equal to source");

        EXPECT_EQ(true, keys_are_sufficiently_distinct(dest, size, dest2, size),
                  "derived keys share too many bytes");
    }

    /* derive with different input */
    memset(dest2, 0, size);
    versioned_args = (struct hwkey_versioned_key_options){
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_RUNNING_VERSION,
            .os_rollback_version = HWKEY_ROLLBACK_VERSION_CURRENT,
            .context = src_data2,
            .context_len = sizeof(src_data2),
            .shared_key = false,
            .key = dest2,
            .key_len = sizeof(dest2),
    };
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc,
              "derive not repeatable versioned - second derivation");

    /* ensure they are not the same */
    rc = memcmp(dest, dest2, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal");
    rc = memcmp(dest, src_data, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal to source");
    rc = memcmp(dest2, src_data2, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal to source");

    EXPECT_EQ(true, keys_are_sufficiently_distinct(dest, size, dest2, size),
              "derived keys share too many bytes");

    /* derive a shared key from the same input and ensure different */
    versioned_args = (struct hwkey_versioned_key_options){
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_RUNNING_VERSION,
            .os_rollback_version = HWKEY_ROLLBACK_VERSION_CURRENT,
            .context = src_data,
            .context_len = sizeof(src_data),
            .shared_key = true,
            .key = dest_shared,
            .key_len = sizeof(dest_shared),
    };
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc,
              "derive not repeatable versioned - second derivation");

    /* ensure they are not the same */
    rc = memcmp(dest, dest_shared, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal");
    rc = memcmp(dest2, dest_shared, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal");
    rc = memcmp(dest_shared, src_data, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal to source");

    EXPECT_EQ(true,
              keys_are_sufficiently_distinct(dest, size, dest_shared, size),
              "derived keys share too many bytes");
    EXPECT_EQ(true,
              keys_are_sufficiently_distinct(dest2, size, dest_shared, size),
              "derived keys share too many bytes");

    /* shared key, different input */
    versioned_args = (struct hwkey_versioned_key_options){
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_RUNNING_VERSION,
            .os_rollback_version = HWKEY_ROLLBACK_VERSION_CURRENT,
            .context = src_data2,
            .context_len = sizeof(src_data2),
            .shared_key = true,
            .key = dest_shared2,
            .key_len = sizeof(dest_shared2),
    };
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc,
              "derive not repeatable versioned - second derivation");

    /* ensure they are not the same */
    rc = memcmp(dest, dest_shared2, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal");
    rc = memcmp(dest2, dest_shared2, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal");
    rc = memcmp(dest_shared, dest_shared2, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal");
    rc = memcmp(dest_shared2, src_data, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal to source");

    EXPECT_EQ(true,
              keys_are_sufficiently_distinct(dest, size, dest_shared, size),
              "derived keys share too many bytes");
    EXPECT_EQ(true,
              keys_are_sufficiently_distinct(dest2, size, dest_shared, size),
              "derived keys share too many bytes");
    EXPECT_EQ(true,
              keys_are_sufficiently_distinct(dest_shared, size, dest_shared2,
                                             size),
              "derived keys share too many bytes");

    /* derive a shared key with the same input but an older OS version */
    if (versioned_args.os_rollback_version >= 1) {
        versioned_args = (struct hwkey_versioned_key_options){
                .kdf_version = HWKEY_KDF_VERSION_BEST,
                .rollback_version_source = HWKEY_ROLLBACK_RUNNING_VERSION,
                .os_rollback_version = versioned_args.os_rollback_version - 1,
                .context = src_data,
                .context_len = sizeof(src_data),
                .shared_key = true,
                .key = dest_shared2,
                .key_len = sizeof(dest_shared2),
        };
        rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
        EXPECT_EQ(NO_ERROR, rc,
                  "derive not repeatable versioned - second derivation");

        /* ensure they are not the same */
        rc = memcmp(dest, dest_shared2, size);
        EXPECT_NE(0, rc, "derive not repeatable - equal");
        rc = memcmp(dest2, dest_shared2, size);
        EXPECT_NE(0, rc, "derive not repeatable - equal");
        rc = memcmp(dest_shared, dest_shared2, size);
        EXPECT_NE(0, rc, "derive not repeatable - equal");
        rc = memcmp(dest_shared2, src_data, size);
        EXPECT_NE(0, rc, "derive not repeatable - equal to source");

        EXPECT_EQ(true,
                  keys_are_sufficiently_distinct(dest, size, dest_shared, size),
                  "derived keys share too many bytes");
        EXPECT_EQ(
                true,
                keys_are_sufficiently_distinct(dest2, size, dest_shared, size),
                "derived keys share too many bytes");
        EXPECT_EQ(true,
                  keys_are_sufficiently_distinct(dest_shared, size,
                                                 dest_shared2, size),
                  "derived keys share too many bytes");
    }
}

TEST_F(hwkey, derive_different_version_source) {
    const uint8_t src_data[] = "thirtytwo-bytes-of-nonsense-data";

    uint8_t dest[32];
    uint8_t dest2[sizeof(dest)];
    uint8_t dest_shared[sizeof(dest)];
    uint8_t dest_shared2[sizeof(dest)];
    static const uint32_t size = sizeof(dest);
    long rc;
    struct hwkey_versioned_key_options versioned_args;

    memset(dest, 0, size);
    memset(dest2, 0, size);
    memset(dest_shared, 0, size);
    memset(dest_shared2, 0, size);

    /* derive with current committed version */
    versioned_args = (struct hwkey_versioned_key_options){
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_COMMITTED_VERSION,
            .os_rollback_version = HWKEY_ROLLBACK_VERSION_CURRENT,
            .context = src_data,
            .context_len = sizeof(src_data),
            .shared_key = false,
            .key = dest,
            .key_len = sizeof(dest),
    };
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc,
              "derive not repeatable versioned - initial derivation");
    EXPECT_NE(HWKEY_KDF_VERSION_BEST, versioned_args.kdf_version,
              "derive not repeatable versioned - kdf version");

    /*
     * derive with the same input and rollback version but a different version
     * source
     */
    versioned_args = (struct hwkey_versioned_key_options){
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_RUNNING_VERSION,
            .os_rollback_version = versioned_args.os_rollback_version,
            .context = src_data,
            .context_len = sizeof(src_data),
            .shared_key = false,
            .key = dest2,
            .key_len = sizeof(dest2),
    };
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc,
              "derive not repeatable versioned - different source");

    if (versioned_args.os_rollback_version > 0) {
        /* not backwards compatible derivation */
        rc = memcmp(dest, dest2, size);
        EXPECT_NE(0, rc, "derive not repeatable - equal");
        rc = memcmp(dest, src_data, size);
        EXPECT_NE(0, rc, "derive not repeatable - equal to source");

        EXPECT_EQ(true, keys_are_sufficiently_distinct(dest, size, dest2, size),
                  "derived keys share too many bytes");
    } else {
        /* backwards compatible derivation, should be the same */
        rc = memcmp(dest, dest2, size);
        EXPECT_EQ(0, rc, "derive not repeatable - not equal");
    }

    /* derive shared key with 0 committed version */
    versioned_args = (struct hwkey_versioned_key_options){
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_COMMITTED_VERSION,
            .os_rollback_version = 0,
            .context = src_data,
            .context_len = sizeof(src_data),
            .shared_key = true,
            .key = dest_shared,
            .key_len = sizeof(dest_shared),
    };
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc,
              "derive not repeatable versioned - initial derivation");

    /* ensure they are not the same */
    rc = memcmp(dest, dest_shared, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal");
    rc = memcmp(dest2, dest_shared, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal");
    rc = memcmp(dest_shared, src_data, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal to source");

    EXPECT_EQ(true,
              keys_are_sufficiently_distinct(dest, size, dest_shared, size),
              "derived keys share too many bytes");
    EXPECT_EQ(true,
              keys_are_sufficiently_distinct(dest2, size, dest_shared, size),
              "derived keys share too many bytes");

    /* derive shared key with 0 running version */
    versioned_args = (struct hwkey_versioned_key_options){
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_RUNNING_VERSION,
            .os_rollback_version = 0,
            .context = src_data,
            .context_len = sizeof(src_data),
            .shared_key = true,
            .key = dest_shared2,
            .key_len = sizeof(dest_shared2),
    };
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc,
              "derive not repeatable versioned - initial derivation");

    /* ensure they are not the same */
    rc = memcmp(dest, dest_shared2, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal");
    rc = memcmp(dest2, dest_shared2, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal");
    rc = memcmp(dest_shared, dest_shared2, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal");
    rc = memcmp(dest_shared2, src_data, size);
    EXPECT_NE(0, rc, "derive not repeatable - equal to source");

    EXPECT_EQ(true,
              keys_are_sufficiently_distinct(dest, size, dest_shared2, size),
              "derived keys share too many bytes");
    EXPECT_EQ(true,
              keys_are_sufficiently_distinct(dest2, size, dest_shared2, size),
              "derived keys share too many bytes");
    EXPECT_EQ(true,
              keys_are_sufficiently_distinct(dest_shared, size, dest_shared2,
                                             size),
              "derived keys share too many bytes");
}

TEST_F(hwkey, derive_zero_length) {
    static const uint32_t size = 0;
    const uint8_t* src_data = NULL;
    uint8_t* dest = NULL;
    uint32_t kdf_version = HWKEY_KDF_VERSION_BEST;

    /* derive key once */
    long rc = hwkey_derive(_state->hwkey_session, &kdf_version, src_data, dest,
                           size);
    EXPECT_EQ(ERR_NOT_VALID, rc, "derive zero length");
}

TEST_F(hwkey, derive_version_query) {
    struct hwkey_versioned_key_options versioned_args = {
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_RUNNING_VERSION,
            .os_rollback_version = HWKEY_ROLLBACK_VERSION_CURRENT,
            .context = NULL,
            .context_len = 0,
            .key = NULL,
            .key_len = 0,
    };

    /* NULL key and context can be used to query the current rollback version */
    long rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc, "versioned derive with zero length");
    EXPECT_NE(HWKEY_ROLLBACK_VERSION_CURRENT,
              versioned_args.os_rollback_version,
              "running rollback version not updated");

    versioned_args.rollback_version_source = HWKEY_ROLLBACK_COMMITTED_VERSION;
    versioned_args.os_rollback_version = HWKEY_ROLLBACK_VERSION_CURRENT;
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc, "versioned derive with zero length");
    EXPECT_NE(HWKEY_ROLLBACK_VERSION_CURRENT,
              versioned_args.os_rollback_version,
              "running rollback version not updated");

    versioned_args.key_len = 42;
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(ERR_NOT_VALID, rc,
              "versioned derive with null key but non-zero length");
}

TEST_F(hwkey, derive_null_context) {
    uint8_t key[32];
    struct hwkey_versioned_key_options versioned_args = {
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_RUNNING_VERSION,
            .os_rollback_version = HWKEY_ROLLBACK_VERSION_CURRENT,
            .context = NULL,
            .context_len = 0,
            .key = key,
            .key_len = sizeof(key),
    };

    long rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_NE(NO_ERROR, rc, "versioned derive with empty context");

    versioned_args.context_len = 42;
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(ERR_NOT_VALID, rc,
              "versioned derive with null context but non-zero length");
}

TEST_F(hwkey, derive_newer_versions) {
    uint8_t key[32];
    long rc;
    struct hwkey_versioned_key_options versioned_args;

    versioned_args = (struct hwkey_versioned_key_options){
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_RUNNING_VERSION,
            .os_rollback_version = HWKEY_ROLLBACK_VERSION_CURRENT,
    };
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc, "versioned derive query failed");

    /* request a newer version */

    versioned_args = (struct hwkey_versioned_key_options){
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_RUNNING_VERSION,
            .os_rollback_version = versioned_args.os_rollback_version + 1,
            .key = key,
            .key_len = sizeof(key),
    };
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_NE(NO_ERROR, rc, "versioned derive with too new running version");

    /* query committed version */
    versioned_args = (struct hwkey_versioned_key_options){
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_COMMITTED_VERSION,
            .os_rollback_version = HWKEY_ROLLBACK_VERSION_CURRENT,
    };
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc, "versioned derive query failed");

    /* request a newer version */
    versioned_args = (struct hwkey_versioned_key_options){
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_COMMITTED_VERSION,
            .os_rollback_version = versioned_args.os_rollback_version + 1,
            .key = key,
            .key_len = sizeof(key),
    };
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_NE(NO_ERROR, rc, "versioned derive with too new committed version");

    /* try a very large version */
    versioned_args = (struct hwkey_versioned_key_options){
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_COMMITTED_VERSION,
            .os_rollback_version = INT32_MAX,
            .key = key,
            .key_len = sizeof(key),
    };
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_NE(NO_ERROR, rc, "versioned derive with far too large version");
}

TEST_F(hwkey, derive_large_payload) {
    const size_t max_payload_size =
            HWKEY_MAX_MSG_SIZE - sizeof(struct hwkey_derive_versioned_msg);
    uint8_t context[HWKEY_MAX_MSG_SIZE];
    uint8_t key[HWKEY_MAX_MSG_SIZE];
    long rc;
    struct hwkey_versioned_key_options versioned_args = {
            .kdf_version = HWKEY_KDF_VERSION_BEST,
            .rollback_version_source = HWKEY_ROLLBACK_RUNNING_VERSION,
            .os_rollback_version = HWKEY_ROLLBACK_VERSION_CURRENT,
            .context = context,
            .context_len = 128,
            .key = key,
            .key_len = 128,
    };

    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(NO_ERROR, rc, "versioned derive with large context and key");

    versioned_args.context_len = max_payload_size + 1;
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(ERR_BAD_LEN, rc, "versioned derive with too large context");

    versioned_args.context_len = 128;
    versioned_args.key_len = max_payload_size + 1;
    rc = hwkey_derive_versioned(_state->hwkey_session, &versioned_args);
    EXPECT_EQ(ERR_BAD_LEN, rc, "versioned derive with too large key");
}

TEST_F(hwkey, get_storage_auth) {
    uint32_t actual_size = STORAGE_AUTH_KEY_SIZE;
    uint8_t storage_auth_key[STORAGE_AUTH_KEY_SIZE];
    long rc = hwkey_get_keyslot_data(_state->hwkey_session,
                                     RPMB_STORAGE_AUTH_KEY_ID, storage_auth_key,
                                     &actual_size);
    EXPECT_EQ(ERR_NOT_FOUND, rc, "auth key accessible when it shouldn't be");
}

TEST_F(hwkey, get_keybox) {
    uint8_t dest[sizeof(HWCRYPTO_UNITTEST_KEYBOX_ID)];
    uint32_t actual_size = sizeof(dest);
    long rc = hwkey_get_keyslot_data(_state->hwkey_session,
                                     HWCRYPTO_UNITTEST_KEYBOX_ID, dest,
                                     &actual_size);

#if WITH_HWCRYPTO_UNITTEST
    EXPECT_EQ(NO_ERROR, rc, "get hwcrypto-unittest keybox");
    rc = memcmp(UNITTEST_KEYSLOT, dest, sizeof(UNITTEST_KEYSLOT) - 1);
    EXPECT_EQ(0, rc, "get storage auth key invalid");
#else
    EXPECT_EQ(ERR_NOT_FOUND, rc, "get hwcrypto-unittest keybox");
#endif
}

/*
 * The derived key slot should return UNITTEST_DERIVED_KEYSLOT after decrypting
 * it with the UNITTEST_KEYSLOT key.
 */
TEST_F(hwkey, get_derived_keybox) {
    uint8_t dest[sizeof(UNITTEST_DERIVED_KEYSLOT) - 1];
    uint32_t actual_size = sizeof(dest);
    long rc = hwkey_get_keyslot_data(_state->hwkey_session,
                                     HWCRYPTO_UNITTEST_DERIVED_KEYBOX_ID, dest,
                                     &actual_size);

#if WITH_HWCRYPTO_UNITTEST
    EXPECT_EQ(NO_ERROR, rc, "get hwcrypto-unittest derived keybox");
    rc = memcmp(UNITTEST_DERIVED_KEYSLOT, dest,
                sizeof(UNITTEST_DERIVED_KEYSLOT) - 1);
    EXPECT_EQ(0, rc, "get derived invalid");
#else
    EXPECT_EQ(ERR_NOT_FOUND, rc, "get hwcrypto-unittest derived keybox");
#endif
}

TEST_F(hwkey, get_opaque_handle) {
    uint8_t dest[HWKEY_OPAQUE_HANDLE_MAX_SIZE] = {0};
    uint32_t actual_size = sizeof(dest);
    long rc = hwkey_get_keyslot_data(_state->hwkey_session,
                                     HWCRYPTO_UNITTEST_OPAQUE_HANDLE_ID, dest,
                                     &actual_size);
#if WITH_HWCRYPTO_UNITTEST
    EXPECT_EQ(NO_ERROR, rc, "get hwcrypto-unittest opaque keybox");
    EXPECT_LE(actual_size, HWKEY_OPAQUE_HANDLE_MAX_SIZE);

    rc = strnlen((const char*)dest, HWKEY_OPAQUE_HANDLE_MAX_SIZE);
    EXPECT_LT(rc, HWKEY_OPAQUE_HANDLE_MAX_SIZE,
              "opaque handle is unexpected size");
#else
    EXPECT_EQ(ERR_NOT_FOUND, rc, "hwcrypto-unittest not enabled");
#endif
}

/* The following tests require hwcrpyto-unittest to do anything useful. */

TEST_F(hwkey, DISABLED_WITHOUT_HWCRYPTO_UNITTEST(get_opaque_key)) {
    uint8_t handle[HWKEY_OPAQUE_HANDLE_MAX_SIZE] = {0};
    uint32_t actual_size = sizeof(handle);
    long rc = hwkey_get_keyslot_data(_state->hwkey_session,
                                     HWCRYPTO_UNITTEST_OPAQUE_HANDLE_ID, handle,
                                     &actual_size);

    EXPECT_EQ(NO_ERROR, rc, "get hwcrypto-unittest opaque keybox");
    EXPECT_LE(actual_size, HWKEY_OPAQUE_HANDLE_MAX_SIZE);
    rc = strnlen((const char*)handle, HWKEY_OPAQUE_HANDLE_MAX_SIZE);
    EXPECT_LT(rc, HWKEY_OPAQUE_HANDLE_MAX_SIZE,
              "Unexpected opaque handle size");

    uint8_t key_buf[sizeof(UNITTEST_KEYSLOT) - 1] = {0};
    actual_size = sizeof(key_buf);
    rc = hwkey_get_keyslot_data(_state->hwkey_session, (const char*)handle,
                                key_buf, &actual_size);
    EXPECT_EQ(NO_ERROR, rc, "get hwcrypto-unittest opaque key failed");

    rc = memcmp(UNITTEST_KEYSLOT, key_buf, sizeof(UNITTEST_KEYSLOT) - 1);
    EXPECT_EQ(0, rc, "opaque key did not match expected value");
}

TEST_F(hwkey, DISABLED_WITHOUT_HWCRYPTO_UNITTEST(get_multiple_opaque_handles)) {
    uint8_t handle1[HWKEY_OPAQUE_HANDLE_MAX_SIZE] = {0};
    uint32_t actual_size = sizeof(handle1);
    long rc = hwkey_get_keyslot_data(_state->hwkey_session,
                                     HWCRYPTO_UNITTEST_OPAQUE_HANDLE_ID,
                                     handle1, &actual_size);
    EXPECT_EQ(NO_ERROR, rc, "get hwcrypto-unittest opaque keybox");
    EXPECT_LE(actual_size, HWKEY_OPAQUE_HANDLE_MAX_SIZE);

    uint8_t handle2[HWKEY_OPAQUE_HANDLE_MAX_SIZE] = {0};
    actual_size = sizeof(handle2);
    rc = hwkey_get_keyslot_data(_state->hwkey_session,
                                HWCRYPTO_UNITTEST_OPAQUE_HANDLE_NOACCESS_ID,
                                handle2, &actual_size);
    EXPECT_EQ(NO_ERROR, rc, "get hwcrypto-unittest opaque keybox");
    EXPECT_LE(actual_size, HWKEY_OPAQUE_HANDLE_MAX_SIZE);

    rc = memcmp(handle1, handle2, HWKEY_OPAQUE_HANDLE_MAX_SIZE);
    EXPECT_NE(0, rc, "opaque handles should not be the same");

    uint8_t key_buf[sizeof(UNITTEST_KEYSLOT)] = {0};
    actual_size = sizeof(key_buf);
    rc = hwkey_get_keyslot_data(_state->hwkey_session, (const char*)handle1,
                                key_buf, &actual_size);
    EXPECT_EQ(NO_ERROR, rc, "handle was not valid");
    EXPECT_EQ(actual_size, sizeof(UNITTEST_KEYSLOT) - 1, "wrong key length");
    rc = memcmp(UNITTEST_KEYSLOT, key_buf, sizeof(UNITTEST_KEYSLOT) - 1);
    EXPECT_EQ(0, rc, "opaque key did not match expected value");

    /* we are not allowed to retrieve key material for the NOACCESS handle */
    memset(key_buf, 0, sizeof(UNITTEST_KEYSLOT));
    actual_size = sizeof(key_buf);
    rc = hwkey_get_keyslot_data(_state->hwkey_session, (const char*)handle2,
                                key_buf, &actual_size);
    EXPECT_EQ(ERR_NOT_FOUND, rc,
              "should not be able to retrieve key for second handle");

    /*
     * We need to reconnect to ensure that the tokens have been dropped and
     * cleared.
     */
    hwkey_close(_state->hwkey_session);
    int new_sess = hwkey_open();
    ASSERT_GE(new_sess, 0);
    _state->hwkey_session = (hwkey_session_t)new_sess;

    /* Has the keyslot data been cleared? */
    memset(key_buf, 0, sizeof(UNITTEST_KEYSLOT));
    actual_size = sizeof(key_buf);
    rc = hwkey_get_keyslot_data(_state->hwkey_session, (const char*)handle1,
                                key_buf, &actual_size);
    EXPECT_EQ(ERR_NOT_FOUND, rc, "handle was still valid");

    actual_size = sizeof(key_buf);
    rc = hwkey_get_keyslot_data(_state->hwkey_session, (const char*)handle2,
                                key_buf, &actual_size);
    EXPECT_EQ(ERR_NOT_FOUND, rc, "handle was still valid");

test_abort:;
}

/*
 * Make sure that attempting to get the same handle from multiple concurrent
 * sessions doesn't break things.
 */
TEST_F(hwkey,
       DISABLED_WITHOUT_HWCRYPTO_UNITTEST(opaque_handle_multiple_sessions)) {
    uint8_t handle1[HWKEY_OPAQUE_HANDLE_MAX_SIZE] = {0};
    uint32_t actual_size = sizeof(handle1);
    long rc = hwkey_get_keyslot_data(_state->hwkey_session,
                                     HWCRYPTO_UNITTEST_OPAQUE_HANDLE_ID,
                                     handle1, &actual_size);
    EXPECT_EQ(NO_ERROR, rc, "get hwcrypto-unittest opaque keybox");
    EXPECT_LE(actual_size, HWKEY_OPAQUE_HANDLE_MAX_SIZE);

    int new_sess = hwkey_open();
    ASSERT_GE(new_sess, 0);

    uint8_t handle2[HWKEY_OPAQUE_HANDLE_MAX_SIZE] = {0};
    actual_size = sizeof(handle2);
    rc = hwkey_get_keyslot_data(new_sess, HWCRYPTO_UNITTEST_OPAQUE_HANDLE_ID,
                                handle2, &actual_size);
    EXPECT_EQ(ERR_ALREADY_EXISTS, rc, "retrieve same handle twice");

    /* Fetch a new handle with a different keyslot from the second session */
    actual_size = sizeof(handle2);
    rc = hwkey_get_keyslot_data(new_sess, HWCRYPTO_UNITTEST_OPAQUE_HANDLE2_ID,
                                handle2, &actual_size);
    EXPECT_EQ(NO_ERROR, rc, "get hwcrypto-unittest opaque keybox");
    EXPECT_LE(actual_size, HWKEY_OPAQUE_HANDLE_MAX_SIZE);

    uint8_t key_buf[sizeof(UNITTEST_KEYSLOT)] = {0};

    /* Fetch the keys via the first session */
    actual_size = sizeof(key_buf);
    rc = hwkey_get_keyslot_data(_state->hwkey_session, (const char*)handle1,
                                key_buf, &actual_size);
    EXPECT_EQ(NO_ERROR, rc, "handle was not valid");
    EXPECT_EQ(actual_size, sizeof(UNITTEST_KEYSLOT) - 1, "wrong key length");
    rc = memcmp(UNITTEST_KEYSLOT, key_buf, sizeof(UNITTEST_KEYSLOT) - 1);
    EXPECT_EQ(0, rc, "opaque key did not match expected value");

    memset(key_buf, 0, sizeof(UNITTEST_KEYSLOT));
    actual_size = sizeof(key_buf);
    rc = hwkey_get_keyslot_data(_state->hwkey_session, (const char*)handle2,
                                key_buf, &actual_size);
    EXPECT_EQ(NO_ERROR, rc, "handle was not valid");
    EXPECT_EQ(actual_size, sizeof(UNITTEST_KEYSLOT) - 1, "wrong key length");
    rc = memcmp(UNITTEST_KEYSLOT, key_buf, sizeof(UNITTEST_KEYSLOT) - 1);
    EXPECT_EQ(0, rc, "opaque key did not match expected value");

    /* Fetch the same key via the second session */
    memset(key_buf, 0, sizeof(UNITTEST_KEYSLOT));
    actual_size = sizeof(key_buf);
    rc = hwkey_get_keyslot_data(new_sess, (const char*)handle1, key_buf,
                                &actual_size);
    EXPECT_EQ(NO_ERROR, rc, "handle was not valid");
    EXPECT_EQ(actual_size, sizeof(UNITTEST_KEYSLOT) - 1, "wrong key length");
    rc = memcmp(UNITTEST_KEYSLOT, key_buf, sizeof(UNITTEST_KEYSLOT) - 1);
    EXPECT_EQ(0, rc, "opaque key did not match expected value");

    memset(key_buf, 0, sizeof(UNITTEST_KEYSLOT));
    actual_size = sizeof(key_buf);
    rc = hwkey_get_keyslot_data(new_sess, (const char*)handle2, key_buf,
                                &actual_size);
    EXPECT_EQ(NO_ERROR, rc, "handle was not valid");
    EXPECT_EQ(actual_size, sizeof(UNITTEST_KEYSLOT) - 1, "wrong key length");
    rc = memcmp(UNITTEST_KEYSLOT, key_buf, sizeof(UNITTEST_KEYSLOT) - 1);
    EXPECT_EQ(0, rc, "opaque key did not match expected value");

    hwkey_close(new_sess);

    /* Has the keyslot data been cleared? */
    actual_size = sizeof(key_buf);
    rc = hwkey_get_keyslot_data(_state->hwkey_session, (const char*)handle1,
                                key_buf, &actual_size);
    EXPECT_EQ(NO_ERROR, rc, "first session handle wasn't valid");

    actual_size = sizeof(key_buf);
    rc = hwkey_get_keyslot_data(_state->hwkey_session, (const char*)handle2,
                                key_buf, &actual_size);
    EXPECT_EQ(ERR_NOT_FOUND, rc, "second session handle was still valid");

    /* Disconnect the original session which retrieved the handle */
    hwkey_close(_state->hwkey_session);
    new_sess = hwkey_open();
    ASSERT_GE(new_sess, 0);
    _state->hwkey_session = (hwkey_session_t)new_sess;

    actual_size = sizeof(key_buf);
    rc = hwkey_get_keyslot_data(_state->hwkey_session, (const char*)handle1,
                                key_buf, &actual_size);
    EXPECT_EQ(ERR_NOT_FOUND, rc, "handle was still valid");

    actual_size = sizeof(key_buf);
    rc = hwkey_get_keyslot_data(_state->hwkey_session, (const char*)handle2,
                                key_buf, &actual_size);
    EXPECT_EQ(ERR_NOT_FOUND, rc, "handle was still valid");

test_abort:;
}

TEST_F(hwkey, DISABLED_WITHOUT_HWCRYPTO_UNITTEST(try_empty_opaque_handle)) {
    /* Reconnect just to make sure there is no spurious handles remaining. */
    hwkey_close(_state->hwkey_session);
    int new_sess = hwkey_open();
    ASSERT_GE(new_sess, 0);
    _state->hwkey_session = (hwkey_session_t)new_sess;

    uint8_t key_buf[sizeof(UNITTEST_KEYSLOT) - 1] = {0};
    uint32_t actual_size = sizeof(key_buf);
    long rc = hwkey_get_keyslot_data(_state->hwkey_session, "", key_buf,
                                     &actual_size);
    EXPECT_EQ(ERR_NOT_FOUND, rc,
              "retrieving a key with an empty access token succeeded");

test_abort:;
}

TEST_F(hwkey, DISABLED_WITHOUT_HWCRYPTO_UNITTEST(get_opaque_derived_key)) {
    uint8_t handle[HWKEY_OPAQUE_HANDLE_MAX_SIZE] = {0};
    uint32_t actual_size = sizeof(handle);
    long rc = hwkey_get_keyslot_data(_state->hwkey_session,
                                     HWCRYPTO_UNITTEST_OPAQUE_DERIVED_ID,
                                     handle, &actual_size);

    EXPECT_EQ(NO_ERROR, rc, "get hwcrypto-unittest opaque derived key");
    EXPECT_LE(actual_size, HWKEY_OPAQUE_HANDLE_MAX_SIZE);
    rc = strnlen((const char*)handle, HWKEY_OPAQUE_HANDLE_MAX_SIZE);
    EXPECT_EQ(rc, actual_size - 1, "Unexpected opaque handle size");

    uint8_t key_buf[sizeof(UNITTEST_DERIVED_KEYSLOT) - 1];
    actual_size = sizeof(key_buf);
    rc = hwkey_get_keyslot_data(_state->hwkey_session, (const char*)handle,
                                key_buf, &actual_size);
    EXPECT_EQ(NO_ERROR, rc, "get hwcrypto-unittest derived key failed");
    EXPECT_EQ(actual_size, sizeof(key_buf), "Unexpected opaque handle size");

    rc = memcmp(UNITTEST_DERIVED_KEYSLOT, key_buf, sizeof(key_buf));
    EXPECT_EQ(0, rc, "get derived invalid");
}

PORT_TEST(hwcrypto, "com.android.trusty.hwcrypto.test")