Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 11c970f7 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Provide alternate SE RoT provisioning path." am: 07011d9e

Original change: https://android-review.googlesource.com/c/platform/hardware/interfaces/+/1982797

Change-Id: Ia74ce0dba7595e9eb8c080c150174b49b7c509b1
parents c6e816aa 07011d9e
Loading
Loading
Loading
Loading
+3 −0
Original line number Diff line number Diff line
@@ -49,5 +49,8 @@ interface IKeyMintDevice {
  void earlyBootEnded();
  byte[] convertStorageKeyToEphemeral(in byte[] storageKeyBlob);
  android.hardware.security.keymint.KeyCharacteristics[] getKeyCharacteristics(in byte[] keyBlob, in byte[] appId, in byte[] appData);
  byte[16] getRootOfTrustChallenge();
  byte[] getRootOfTrust(in byte[16] challenge);
  void sendRootOfTrust(in byte[] rootOfTrust);
  const int AUTH_TOKEN_MAC_LENGTH = 32;
}
+78 −0
Original line number Diff line number Diff line
@@ -851,4 +851,82 @@ interface IKeyMintDevice {
     */
    KeyCharacteristics[] getKeyCharacteristics(
            in byte[] keyBlob, in byte[] appId, in byte[] appData);

    /**
     * Returns a 16-byte random challenge nonce, used to prove freshness when exchanging root of
     * trust data.
     *
     * This method may only be implemented by StrongBox KeyMint.  TEE KeyMint implementations must
     * return ErrorCode::UNIMPLEMENTED.  StrongBox KeyMint implementations MAY return UNIMPLEMENTED,
     * to indicate that they have an alternative mechanism for getting the data.  If the StrongBox
     * implementation returns UNIMPLEMENTED, the client should not call `getRootofTrust()` or
     * `sendRootOfTrust()`.
     */
    byte[16] getRootOfTrustChallenge();

    /**
     * Returns the TEE KeyMint Root of Trust data.
     *
     * This method is required for TEE KeyMint.  StrongBox KeyMint implementations MUST return
     * ErrorCode::UNIMPLEMENTED.
     *
     * The returned data is an encoded COSE_Mac0 structure, denoted MacedRootOfTrust in the
     * following CDDL schema.  Note that K_mac is the shared HMAC key used for auth tokens, etc.:
     *
     *     MacedRootOfTrust = [               ; COSE_Mac0 (untagged)
     *         protected: bstr .cbor {
     *             1 : 5,                     ; Algorithm : HMAC-256
     *         },
     *         unprotected : {},
     *         payload : bstr .cbor RootOfTrust,
     *         tag : bstr HMAC-256(K_mac, MAC_structure)
     *     ]
     *
     *     MAC_structure = [
     *         context : "MAC0",
     *         protected : bstr .cbor {
     *             1 : 5,                     ; Algorithm : HMAC-256
     *         },
     *         external_aad : bstr .size 16   ; Value of challenge argument
     *         payload : bstr .cbor RootOfTrust,
     *     ]
     *
     *     RootOfTrust = [
     *         verifiedBootKey : bstr .size 32,
     *         deviceLocked : bool,
     *         verifiedBootState : &VerifiedBootState,
     *         verifiedBootHash : bstr .size 32,
     *         bootPatchLevel : int,          ; See Tag::BOOT_PATCHLEVEL
     *     ]
     *
     *     VerifiedBootState = (
     *         Verified : 0,
     *         SelfSigned : 1,
     *         Unverified : 2,
     *         Failed : 3
     *     )
     */
    byte[] getRootOfTrust(in byte[16] challenge);

    /**
     * Delivers the TEE KeyMint Root of Trust data to StrongBox KeyMint.  See `getRootOfTrust()`
     * above for specification of the data format and cryptographic security structure.
     *
     * The implementation must verify the MAC on the RootOfTrust data.  If it is valid, and if this
     * is the first time since reboot that StrongBox KeyMint has received this data, it must store
     * the RoT data for use in key attestation requests, then return ErrorCode::ERROR_OK.
     *
     * If the MAC on the Root of Trust data and challenge is incorrect, the implementation must
     * return ErrorCode::VERIFICATION_FAILED.
     *
     * If the RootOfTrust data has already been received since the last boot, the implementation
     * must validate the data and return ErrorCode::VERIFICATION_FAILED or ErrorCode::ERROR_OK
     * according to the result, but must not store the data for use in key attestation requests,
     * even if verification succeeds.  On success, the challenge is invalidated and a new challenge
     * must be requested before the RootOfTrust data may be sent again.
     *
     * This method is optional for StrongBox KeyMint, which MUST return ErrorCode::UNIMPLEMENTED if
     * not implemented.  TEE KeyMint implementations must return ErrorCode::UNIMPLEMENTED.
     */
    void sendRootOfTrust(in byte[] rootOfTrust);
}
+1 −0
Original line number Diff line number Diff line
@@ -54,6 +54,7 @@ cc_test {
        "AttestKeyTest.cpp",
        "DeviceUniqueAttestationTest.cpp",
        "KeyMintTest.cpp",
        "SecureElementProvisioningTest.cpp",
    ],
    static_libs: [
        "libkeymint_vts_test_utils",
+255 −0
Original line number Diff line number Diff line
/*
 * Copyright (C) 2021 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.
 */

#define LOG_TAG "keymint_2_se_provisioning_test"

#include <map>
#include <memory>
#include <vector>

#include <android-base/logging.h>
#include <android/binder_manager.h>

#include <cppbor_parse.h>
#include <keymaster/cppcose/cppcose.h>
#include <keymint_support/key_param_output.h>

#include "KeyMintAidlTestBase.h"

namespace aidl::android::hardware::security::keymint::test {

using std::array;
using std::map;
using std::shared_ptr;
using std::vector;

class SecureElementProvisioningTest : public testing::Test {
  protected:
    static void SetupTestSuite() {
        auto params = ::android::getAidlHalInstanceNames(IKeyMintDevice::descriptor);
        for (auto& param : params) {
            ASSERT_TRUE(AServiceManager_isDeclared(param.c_str()))
                    << "IKeyMintDevice instance " << param << " found but not declared.";
            ::ndk::SpAIBinder binder(AServiceManager_waitForService(param.c_str()));
            auto keymint = IKeyMintDevice::fromBinder(binder);
            ASSERT_NE(keymint, nullptr) << "Failed to get IKeyMintDevice instance " << param;

            KeyMintHardwareInfo info;
            ASSERT_TRUE(keymint->getHardwareInfo(&info).isOk());
            ASSERT_EQ(keymints_.count(info.securityLevel), 0)
                    << "There must be exactly one IKeyMintDevice with security level "
                    << info.securityLevel;

            keymints_[info.securityLevel] = std::move(keymint);
        }
    }

    static map<SecurityLevel, shared_ptr<IKeyMintDevice>> keymints_;
};

map<SecurityLevel, shared_ptr<IKeyMintDevice>> SecureElementProvisioningTest::keymints_;

TEST_F(SecureElementProvisioningTest, ValidConfigurations) {
    // TEE is required
    ASSERT_EQ(keymints_.count(SecurityLevel::TRUSTED_ENVIRONMENT), 1);
    // StrongBox is optional
    ASSERT_LE(keymints_.count(SecurityLevel::STRONGBOX), 1);
}

TEST_F(SecureElementProvisioningTest, TeeOnly) {
    ASSERT_EQ(keymints_.count(SecurityLevel::TRUSTED_ENVIRONMENT), 1);
    auto tee = keymints_.find(SecurityLevel::TRUSTED_ENVIRONMENT)->second;
    ASSERT_NE(tee, nullptr);

    array<uint8_t, 16> challenge1 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    array<uint8_t, 16> challenge2 = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

    vector<uint8_t> rootOfTrust1;
    Status result = tee->getRootOfTrust(challenge1, &rootOfTrust1);

    // TODO: Remove the next line to require TEEs to succeed.
    if (!result.isOk()) return;

    ASSERT_TRUE(result.isOk());

    // TODO:  Parse and validate rootOfTrust1 here

    vector<uint8_t> rootOfTrust2;
    result = tee->getRootOfTrust(challenge2, &rootOfTrust2);
    ASSERT_TRUE(result.isOk());

    // TODO:  Parse and validate rootOfTrust2 here

    ASSERT_NE(rootOfTrust1, rootOfTrust2);

    vector<uint8_t> rootOfTrust3;
    result = tee->getRootOfTrust(challenge1, &rootOfTrust3);
    ASSERT_TRUE(result.isOk());

    ASSERT_EQ(rootOfTrust1, rootOfTrust3);

    // TODO:  Parse and validate rootOfTrust3 here
}

TEST_F(SecureElementProvisioningTest, TeeDoesNotImplementStrongBoxMethods) {
    ASSERT_EQ(keymints_.count(SecurityLevel::TRUSTED_ENVIRONMENT), 1);
    auto tee = keymints_.find(SecurityLevel::TRUSTED_ENVIRONMENT)->second;
    ASSERT_NE(tee, nullptr);

    array<uint8_t, 16> challenge;
    Status result = tee->getRootOfTrustChallenge(&challenge);
    ASSERT_FALSE(result.isOk());
    ASSERT_EQ(result.getExceptionCode(), EX_SERVICE_SPECIFIC);
    ASSERT_EQ(static_cast<ErrorCode>(result.getServiceSpecificError()), ErrorCode::UNIMPLEMENTED);

    result = tee->sendRootOfTrust({});
    ASSERT_FALSE(result.isOk());
    ASSERT_EQ(result.getExceptionCode(), EX_SERVICE_SPECIFIC);
    ASSERT_EQ(static_cast<ErrorCode>(result.getServiceSpecificError()), ErrorCode::UNIMPLEMENTED);
}

TEST_F(SecureElementProvisioningTest, StrongBoxDoesNotImplementTeeMethods) {
    if (keymints_.count(SecurityLevel::STRONGBOX) == 0) return;

    auto sb = keymints_.find(SecurityLevel::STRONGBOX)->second;
    ASSERT_NE(sb, nullptr);

    vector<uint8_t> rootOfTrust;
    Status result = sb->getRootOfTrust({}, &rootOfTrust);
    ASSERT_FALSE(result.isOk());
    ASSERT_EQ(result.getExceptionCode(), EX_SERVICE_SPECIFIC);
    ASSERT_EQ(static_cast<ErrorCode>(result.getServiceSpecificError()), ErrorCode::UNIMPLEMENTED);
}

TEST_F(SecureElementProvisioningTest, UnimplementedTest) {
    if (keymints_.count(SecurityLevel::STRONGBOX) == 0) return;  // Need a StrongBox to provision.

    ASSERT_EQ(keymints_.count(SecurityLevel::TRUSTED_ENVIRONMENT), 1);
    auto tee = keymints_.find(SecurityLevel::TRUSTED_ENVIRONMENT)->second;
    ASSERT_NE(tee, nullptr);

    ASSERT_EQ(keymints_.count(SecurityLevel::STRONGBOX), 1);
    auto sb = keymints_.find(SecurityLevel::STRONGBOX)->second;
    ASSERT_NE(sb, nullptr);

    array<uint8_t, 16> challenge;
    Status result = sb->getRootOfTrustChallenge(&challenge);
    if (!result.isOk()) {
        // Strongbox does not have to implement this feature if it has uses an alternative mechanism
        // to provision the root of trust.  In that case it MUST return UNIMPLEMENTED, both from
        // getRootOfTrustChallenge() and from sendRootOfTrust().
        ASSERT_EQ(result.getExceptionCode(), EX_SERVICE_SPECIFIC);
        ASSERT_EQ(static_cast<ErrorCode>(result.getServiceSpecificError()),
                  ErrorCode::UNIMPLEMENTED);

        result = sb->sendRootOfTrust({});
        ASSERT_EQ(result.getExceptionCode(), EX_SERVICE_SPECIFIC);
        ASSERT_EQ(static_cast<ErrorCode>(result.getServiceSpecificError()),
                  ErrorCode::UNIMPLEMENTED);

        SUCCEED() << "This Strongbox implementation does not use late root of trust delivery.";
        return;
    }
}

TEST_F(SecureElementProvisioningTest, ChallengeQualityTest) {
    if (keymints_.count(SecurityLevel::STRONGBOX) == 0) return;  // Need a StrongBox to provision.

    ASSERT_EQ(keymints_.count(SecurityLevel::STRONGBOX), 1);
    auto sb = keymints_.find(SecurityLevel::STRONGBOX)->second;
    ASSERT_NE(sb, nullptr);

    array<uint8_t, 16> challenge1;
    Status result = sb->getRootOfTrustChallenge(&challenge1);
    if (!result.isOk()) return;

    array<uint8_t, 16> challenge2;
    result = sb->getRootOfTrustChallenge(&challenge2);
    ASSERT_TRUE(result.isOk());
    ASSERT_NE(challenge1, challenge2);

    // TODO: When we add entropy testing in other relevant places in these tests, add it here, too,
    // to verify that challenges appear to have adequate entropy.
}

TEST_F(SecureElementProvisioningTest, ProvisioningTest) {
    if (keymints_.count(SecurityLevel::STRONGBOX) == 0) return;  // Need a StrongBox to provision.

    ASSERT_EQ(keymints_.count(SecurityLevel::TRUSTED_ENVIRONMENT), 1);
    auto tee = keymints_.find(SecurityLevel::TRUSTED_ENVIRONMENT)->second;
    ASSERT_NE(tee, nullptr);

    ASSERT_EQ(keymints_.count(SecurityLevel::STRONGBOX), 1);
    auto sb = keymints_.find(SecurityLevel::STRONGBOX)->second;
    ASSERT_NE(sb, nullptr);

    array<uint8_t, 16> challenge;
    Status result = sb->getRootOfTrustChallenge(&challenge);
    if (!result.isOk()) return;

    vector<uint8_t> rootOfTrust;
    result = tee->getRootOfTrust(challenge, &rootOfTrust);
    ASSERT_TRUE(result.isOk());

    // TODO: Verify COSE_Mac0 structure and content here.

    result = sb->sendRootOfTrust(rootOfTrust);
    ASSERT_TRUE(result.isOk());

    // Sending again must fail, because a new challenge is required.
    result = sb->sendRootOfTrust(rootOfTrust);
    ASSERT_FALSE(result.isOk());
}

TEST_F(SecureElementProvisioningTest, InvalidProvisioningTest) {
    if (keymints_.count(SecurityLevel::STRONGBOX) == 0) return;  // Need a StrongBox to provision.

    ASSERT_EQ(keymints_.count(SecurityLevel::TRUSTED_ENVIRONMENT), 1);
    auto tee = keymints_.find(SecurityLevel::TRUSTED_ENVIRONMENT)->second;
    ASSERT_NE(tee, nullptr);

    ASSERT_EQ(keymints_.count(SecurityLevel::STRONGBOX), 1);
    auto sb = keymints_.find(SecurityLevel::STRONGBOX)->second;
    ASSERT_NE(sb, nullptr);

    array<uint8_t, 16> challenge;
    Status result = sb->getRootOfTrustChallenge(&challenge);
    if (!result.isOk()) return;

    result = sb->sendRootOfTrust({});
    ASSERT_FALSE(result.isOk());
    ASSERT_EQ(result.getExceptionCode(), EX_SERVICE_SPECIFIC);
    ASSERT_EQ(static_cast<ErrorCode>(result.getServiceSpecificError()),
              ErrorCode::VERIFICATION_FAILED);

    vector<uint8_t> rootOfTrust;
    result = tee->getRootOfTrust(challenge, &rootOfTrust);
    ASSERT_TRUE(result.isOk());

    vector<uint8_t> corruptedRootOfTrust = rootOfTrust;
    corruptedRootOfTrust[corruptedRootOfTrust.size() / 2]++;
    result = sb->sendRootOfTrust(corruptedRootOfTrust);
    ASSERT_FALSE(result.isOk());
    ASSERT_EQ(result.getExceptionCode(), EX_SERVICE_SPECIFIC);
    ASSERT_EQ(static_cast<ErrorCode>(result.getServiceSpecificError()),
              ErrorCode::VERIFICATION_FAILED);

    // Now try the correct RoT
    result = sb->sendRootOfTrust(rootOfTrust);
    ASSERT_TRUE(result.isOk());
}

}  // namespace aidl::android::hardware::security::keymint::test