| /* |
| * Copyright (C) 2023 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 "authgraph_session_test" |
| #include <android-base/logging.h> |
| |
| #include <aidl/Gtest.h> |
| #include <aidl/Vintf.h> |
| #include <aidl/android/hardware/security/authgraph/Error.h> |
| #include <aidl/android/hardware/security/authgraph/IAuthGraphKeyExchange.h> |
| #include <android/binder_manager.h> |
| #include <binder/ProcessState.h> |
| #include <gtest/gtest.h> |
| #include <vector> |
| |
| namespace aidl::android::hardware::security::authgraph::test { |
| using ::aidl::android::hardware::security::authgraph::Error; |
| |
| namespace { |
| |
| // Check that the signature in the encoded COSE_Sign1 data is correct, and that the payload matches. |
| // TODO: maybe drop separate payload, and extract it from cose_sign1.payload (and return it). |
| void CheckSignature(std::vector<uint8_t>& /*pub_cose_key*/, std::vector<uint8_t>& /*payload*/, |
| std::vector<uint8_t>& /*cose_sign1*/) { |
| // TODO: implement me |
| } |
| |
| void CheckSignature(std::vector<uint8_t>& pub_cose_key, std::vector<uint8_t>& payload, |
| SessionIdSignature& signature) { |
| return CheckSignature(pub_cose_key, payload, signature.signature); |
| } |
| |
| std::vector<uint8_t> SigningKeyFromIdentity(const Identity& identity) { |
| // TODO: This is a CBOR-encoded `Identity` which currently happens to be a COSE_Key with the |
| // pubkey This will change in future. |
| return identity.identity; |
| } |
| |
| } // namespace |
| |
| class AuthGraphSessionTest : public ::testing::TestWithParam<std::string> { |
| public: |
| enum ErrorType { AIDL_ERROR, BINDER_ERROR }; |
| |
| union ErrorValue { |
| Error aidl_error; |
| int32_t binder_error; |
| }; |
| |
| struct ReturnedError { |
| ErrorType err_type; |
| ErrorValue err_val; |
| |
| friend bool operator==(const ReturnedError& lhs, const ReturnedError& rhs) { |
| return lhs.err_type == rhs.err_type; |
| switch (lhs.err_type) { |
| case ErrorType::AIDL_ERROR: |
| return lhs.err_val.aidl_error == rhs.err_val.aidl_error; |
| case ErrorType::BINDER_ERROR: |
| return lhs.err_val.binder_error == rhs.err_val.binder_error; |
| } |
| } |
| }; |
| |
| const ReturnedError OK = {.err_type = ErrorType::AIDL_ERROR, .err_val.aidl_error = Error::OK}; |
| |
| ReturnedError GetReturnError(const ::ndk::ScopedAStatus& result) { |
| if (result.isOk()) { |
| return OK; |
| } |
| int32_t exception_code = result.getExceptionCode(); |
| int32_t error_code = result.getServiceSpecificError(); |
| if (exception_code == EX_SERVICE_SPECIFIC && error_code != 0) { |
| ReturnedError re = {.err_type = ErrorType::AIDL_ERROR, |
| .err_val.aidl_error = static_cast<Error>(error_code)}; |
| return re; |
| } |
| ReturnedError re = {.err_type = ErrorType::BINDER_ERROR, |
| .err_val.binder_error = exception_code}; |
| return re; |
| } |
| |
| // Build the parameters for the VTS test by enumerating the available HAL instances |
| static std::vector<std::string> build_params() { |
| auto params = ::android::getAidlHalInstanceNames(IAuthGraphKeyExchange::descriptor); |
| return params; |
| } |
| |
| void SetUp() override { |
| ASSERT_TRUE(AServiceManager_isDeclared(GetParam().c_str())) |
| << "No instance declared for " << GetParam(); |
| ::ndk::SpAIBinder binder(AServiceManager_waitForService(GetParam().c_str())); |
| authNode_ = IAuthGraphKeyExchange::fromBinder(binder); |
| ASSERT_NE(authNode_, nullptr) << "Failed to get Binder reference for " << GetParam(); |
| } |
| |
| void TearDown() override {} |
| |
| protected: |
| std::shared_ptr<IAuthGraphKeyExchange> authNode_; |
| }; |
| |
| TEST_P(AuthGraphSessionTest, Mainline) { |
| std::shared_ptr<IAuthGraphKeyExchange> source = authNode_; |
| std::shared_ptr<IAuthGraphKeyExchange> sink = authNode_; |
| |
| // Step 1: create an ephemeral ECDH key at the source. |
| SessionInitiationInfo source_init_info; |
| ASSERT_EQ(OK, GetReturnError(source->create(&source_init_info))); |
| ASSERT_TRUE(source_init_info.key.pubKey.has_value()); |
| ASSERT_TRUE(source_init_info.key.arcFromPBK.has_value()); |
| |
| // Step 2: pass the source's ECDH public key and other session info to the sink. |
| KeInitResult init_result; |
| ASSERT_EQ(OK, GetReturnError(sink->init(source_init_info.key.pubKey.value(), |
| source_init_info.identity, source_init_info.nonce, |
| source_init_info.version, &init_result))); |
| SessionInitiationInfo sink_init_info = init_result.sessionInitiationInfo; |
| ASSERT_TRUE(sink_init_info.key.pubKey.has_value()); |
| // The sink_init_info.arcFromPBK need not be populated, as the ephemeral key agreement |
| // key is no longer needed. |
| |
| SessionInfo sink_info = init_result.sessionInfo; |
| ASSERT_EQ((int)sink_info.sharedKeys.size(), 2) << "Expect two symmetric keys from init()"; |
| ASSERT_GT((int)sink_info.sessionId.size(), 0) << "Expect non-empty session ID from sink"; |
| std::vector<uint8_t> sink_signing_key = SigningKeyFromIdentity(sink_init_info.identity); |
| CheckSignature(sink_signing_key, sink_info.sessionId, sink_info.signature); |
| |
| // Step 3: pass the sink's ECDH public key and other session info to the source, so it can |
| // calculate the same pair of symmetric keys. |
| SessionInfo source_info; |
| ASSERT_EQ(OK, GetReturnError(source->finish(sink_init_info.key.pubKey.value(), |
| sink_init_info.identity, sink_info.signature, |
| sink_init_info.nonce, sink_init_info.version, |
| source_init_info.key, &source_info))); |
| ASSERT_EQ((int)source_info.sharedKeys.size(), 2) << "Expect two symmetric keys from finsh()"; |
| ASSERT_GT((int)source_info.sessionId.size(), 0) << "Expect non-empty session ID from source"; |
| std::vector<uint8_t> source_signing_key = SigningKeyFromIdentity(source_init_info.identity); |
| CheckSignature(source_signing_key, source_info.sessionId, source_info.signature); |
| |
| // Both ends should agree on the session ID. |
| ASSERT_EQ(source_info.sessionId, sink_info.sessionId); |
| |
| // Step 4: pass the source's session ID info back to the sink, so it can check it and |
| // update the symmetric keys so they're marked as authentication complete. |
| std::array<Arc, 2> auth_complete_result; |
| ASSERT_EQ(OK, GetReturnError(sink->authenticationComplete( |
| source_info.signature, sink_info.sharedKeys, &auth_complete_result))); |
| ASSERT_EQ((int)auth_complete_result.size(), 2) |
| << "Expect two symmetric keys from authComplete()"; |
| sink_info.sharedKeys = auth_complete_result; |
| |
| // At this point the sink and source have agreed on the same pair of symmetric keys, |
| // encoded as `sink_info.sharedKeys` and `source_info.sharedKeys`. |
| } |
| |
| TEST_P(AuthGraphSessionTest, ParallelSink) { |
| std::shared_ptr<IAuthGraphKeyExchange> source = authNode_; |
| std::shared_ptr<IAuthGraphKeyExchange> sink1 = authNode_; |
| std::shared_ptr<IAuthGraphKeyExchange> sink2 = authNode_; |
| |
| // Step 1: create ephemeral ECDH keys at the source. |
| SessionInitiationInfo source_init1_info; |
| ASSERT_EQ(OK, GetReturnError(source->create(&source_init1_info))); |
| ASSERT_TRUE(source_init1_info.key.pubKey.has_value()); |
| ASSERT_TRUE(source_init1_info.key.arcFromPBK.has_value()); |
| SessionInitiationInfo source_init2_info; |
| ASSERT_EQ(OK, GetReturnError(source->create(&source_init2_info))); |
| ASSERT_TRUE(source_init2_info.key.pubKey.has_value()); |
| ASSERT_TRUE(source_init2_info.key.arcFromPBK.has_value()); |
| |
| // Step 2: pass the source's ECDH public keys and other session info to the sinks. |
| KeInitResult init1_result; |
| ASSERT_EQ(OK, GetReturnError(sink1->init(source_init1_info.key.pubKey.value(), |
| source_init1_info.identity, source_init1_info.nonce, |
| source_init1_info.version, &init1_result))); |
| SessionInitiationInfo sink1_init_info = init1_result.sessionInitiationInfo; |
| ASSERT_TRUE(sink1_init_info.key.pubKey.has_value()); |
| |
| SessionInfo sink1_info = init1_result.sessionInfo; |
| ASSERT_EQ((int)sink1_info.sharedKeys.size(), 2) << "Expect two symmetric keys from init()"; |
| ASSERT_GT((int)sink1_info.sessionId.size(), 0) << "Expect non-empty session ID from sink"; |
| std::vector<uint8_t> sink1_signing_key = SigningKeyFromIdentity(sink1_init_info.identity); |
| CheckSignature(sink1_signing_key, sink1_info.sessionId, sink1_info.signature); |
| KeInitResult init2_result; |
| ASSERT_EQ(OK, GetReturnError(sink2->init(source_init2_info.key.pubKey.value(), |
| source_init2_info.identity, source_init2_info.nonce, |
| source_init2_info.version, &init2_result))); |
| SessionInitiationInfo sink2_init_info = init2_result.sessionInitiationInfo; |
| ASSERT_TRUE(sink2_init_info.key.pubKey.has_value()); |
| |
| SessionInfo sink2_info = init2_result.sessionInfo; |
| ASSERT_EQ((int)sink2_info.sharedKeys.size(), 2) << "Expect two symmetric keys from init()"; |
| ASSERT_GT((int)sink2_info.sessionId.size(), 0) << "Expect non-empty session ID from sink"; |
| std::vector<uint8_t> sink2_signing_key = SigningKeyFromIdentity(sink2_init_info.identity); |
| CheckSignature(sink2_signing_key, sink2_info.sessionId, sink2_info.signature); |
| |
| // Step 3: pass each sink's ECDH public key and other session info to the source, so it can |
| // calculate the same pair of symmetric keys. |
| SessionInfo source_info1; |
| ASSERT_EQ(OK, GetReturnError(source->finish(sink1_init_info.key.pubKey.value(), |
| sink1_init_info.identity, sink1_info.signature, |
| sink1_init_info.nonce, sink1_init_info.version, |
| source_init1_info.key, &source_info1))); |
| ASSERT_EQ((int)source_info1.sharedKeys.size(), 2) << "Expect two symmetric keys from finsh()"; |
| ASSERT_GT((int)source_info1.sessionId.size(), 0) << "Expect non-empty session ID from source"; |
| std::vector<uint8_t> source_signing_key1 = SigningKeyFromIdentity(source_init1_info.identity); |
| CheckSignature(source_signing_key1, source_info1.sessionId, source_info1.signature); |
| SessionInfo source_info2; |
| ASSERT_EQ(OK, GetReturnError(source->finish(sink2_init_info.key.pubKey.value(), |
| sink2_init_info.identity, sink2_info.signature, |
| sink2_init_info.nonce, sink2_init_info.version, |
| source_init2_info.key, &source_info2))); |
| ASSERT_EQ((int)source_info2.sharedKeys.size(), 2) << "Expect two symmetric keys from finsh()"; |
| ASSERT_GT((int)source_info2.sessionId.size(), 0) << "Expect non-empty session ID from source"; |
| std::vector<uint8_t> source_signing_key2 = SigningKeyFromIdentity(source_init2_info.identity); |
| CheckSignature(source_signing_key2, source_info2.sessionId, source_info2.signature); |
| |
| // Both ends should agree on the session ID. |
| ASSERT_EQ(source_info1.sessionId, sink1_info.sessionId); |
| ASSERT_EQ(source_info2.sessionId, sink2_info.sessionId); |
| |
| // Step 4: pass the source's session ID info back to the sink, so it can check it and |
| // update the symmetric keys so they're marked as authentication complete. |
| std::array<Arc, 2> auth_complete_result1; |
| ASSERT_EQ(OK, GetReturnError(sink1->authenticationComplete( |
| source_info1.signature, sink1_info.sharedKeys, &auth_complete_result1))); |
| ASSERT_EQ((int)auth_complete_result1.size(), 2) |
| << "Expect two symmetric keys from authComplete()"; |
| sink1_info.sharedKeys = auth_complete_result1; |
| std::array<Arc, 2> auth_complete_result2; |
| ASSERT_EQ(OK, GetReturnError(sink2->authenticationComplete( |
| source_info2.signature, sink2_info.sharedKeys, &auth_complete_result2))); |
| ASSERT_EQ((int)auth_complete_result2.size(), 2) |
| << "Expect two symmetric keys from authComplete()"; |
| sink2_info.sharedKeys = auth_complete_result2; |
| } |
| |
| TEST_P(AuthGraphSessionTest, ParallelSource) { |
| std::shared_ptr<IAuthGraphKeyExchange> source1 = authNode_; |
| std::shared_ptr<IAuthGraphKeyExchange> source2 = authNode_; |
| std::shared_ptr<IAuthGraphKeyExchange> sink = authNode_; |
| |
| // Step 1: create an ephemeral ECDH key at each of the sources. |
| SessionInitiationInfo source1_init_info; |
| ASSERT_EQ(OK, GetReturnError(source1->create(&source1_init_info))); |
| ASSERT_TRUE(source1_init_info.key.pubKey.has_value()); |
| ASSERT_TRUE(source1_init_info.key.arcFromPBK.has_value()); |
| SessionInitiationInfo source2_init_info; |
| ASSERT_EQ(OK, GetReturnError(source1->create(&source2_init_info))); |
| ASSERT_TRUE(source2_init_info.key.pubKey.has_value()); |
| ASSERT_TRUE(source2_init_info.key.arcFromPBK.has_value()); |
| |
| // Step 2: pass each source's ECDH public key and other session info to the sink. |
| KeInitResult init1_result; |
| ASSERT_EQ(OK, GetReturnError(sink->init(source1_init_info.key.pubKey.value(), |
| source1_init_info.identity, source1_init_info.nonce, |
| source1_init_info.version, &init1_result))); |
| SessionInitiationInfo sink_init1_info = init1_result.sessionInitiationInfo; |
| ASSERT_TRUE(sink_init1_info.key.pubKey.has_value()); |
| |
| SessionInfo sink_info1 = init1_result.sessionInfo; |
| ASSERT_EQ((int)sink_info1.sharedKeys.size(), 2) << "Expect two symmetric keys from init()"; |
| ASSERT_GT((int)sink_info1.sessionId.size(), 0) << "Expect non-empty session ID from sink"; |
| std::vector<uint8_t> sink_signing_key1 = SigningKeyFromIdentity(sink_init1_info.identity); |
| CheckSignature(sink_signing_key1, sink_info1.sessionId, sink_info1.signature); |
| |
| KeInitResult init2_result; |
| ASSERT_EQ(OK, GetReturnError(sink->init(source2_init_info.key.pubKey.value(), |
| source2_init_info.identity, source2_init_info.nonce, |
| source2_init_info.version, &init2_result))); |
| SessionInitiationInfo sink_init2_info = init2_result.sessionInitiationInfo; |
| ASSERT_TRUE(sink_init2_info.key.pubKey.has_value()); |
| |
| SessionInfo sink_info2 = init2_result.sessionInfo; |
| ASSERT_EQ((int)sink_info2.sharedKeys.size(), 2) << "Expect two symmetric keys from init()"; |
| ASSERT_GT((int)sink_info2.sessionId.size(), 0) << "Expect non-empty session ID from sink"; |
| std::vector<uint8_t> sink_signing_key2 = SigningKeyFromIdentity(sink_init2_info.identity); |
| CheckSignature(sink_signing_key2, sink_info2.sessionId, sink_info2.signature); |
| |
| // Step 3: pass the sink's ECDH public keys and other session info to the each of the sources. |
| SessionInfo source1_info; |
| ASSERT_EQ(OK, GetReturnError(source1->finish(sink_init1_info.key.pubKey.value(), |
| sink_init1_info.identity, sink_info1.signature, |
| sink_init1_info.nonce, sink_init1_info.version, |
| source1_init_info.key, &source1_info))); |
| ASSERT_EQ((int)source1_info.sharedKeys.size(), 2) << "Expect two symmetric keys from finsh()"; |
| ASSERT_GT((int)source1_info.sessionId.size(), 0) << "Expect non-empty session ID from source"; |
| std::vector<uint8_t> source1_signing_key = SigningKeyFromIdentity(source1_init_info.identity); |
| CheckSignature(source1_signing_key, source1_info.sessionId, source1_info.signature); |
| |
| SessionInfo source2_info; |
| ASSERT_EQ(OK, GetReturnError(source2->finish(sink_init2_info.key.pubKey.value(), |
| sink_init2_info.identity, sink_info2.signature, |
| sink_init2_info.nonce, sink_init2_info.version, |
| source2_init_info.key, &source2_info))); |
| ASSERT_EQ((int)source2_info.sharedKeys.size(), 2) << "Expect two symmetric keys from finsh()"; |
| ASSERT_GT((int)source2_info.sessionId.size(), 0) << "Expect non-empty session ID from source"; |
| std::vector<uint8_t> source2_signing_key = SigningKeyFromIdentity(source2_init_info.identity); |
| CheckSignature(source2_signing_key, source2_info.sessionId, source2_info.signature); |
| |
| // Both ends should agree on the session ID. |
| ASSERT_EQ(source1_info.sessionId, sink_info1.sessionId); |
| ASSERT_EQ(source2_info.sessionId, sink_info2.sessionId); |
| |
| // Step 4: pass the each source's session ID info back to the sink, so it can check it and |
| // update the symmetric keys so they're marked as authentication complete. |
| std::array<Arc, 2> auth_complete_result1; |
| ASSERT_EQ(OK, GetReturnError(sink->authenticationComplete( |
| source1_info.signature, sink_info1.sharedKeys, &auth_complete_result1))); |
| ASSERT_EQ((int)auth_complete_result1.size(), 2) |
| << "Expect two symmetric keys from authComplete()"; |
| sink_info1.sharedKeys = auth_complete_result1; |
| std::array<Arc, 2> auth_complete_result2; |
| ASSERT_EQ(OK, GetReturnError(sink->authenticationComplete( |
| source2_info.signature, sink_info2.sharedKeys, &auth_complete_result2))); |
| ASSERT_EQ((int)auth_complete_result2.size(), 2) |
| << "Expect two symmetric keys from authComplete()"; |
| sink_info2.sharedKeys = auth_complete_result2; |
| } |
| |
| TEST_P(AuthGraphSessionTest, FreshNonces) { |
| std::shared_ptr<IAuthGraphKeyExchange> source = authNode_; |
| std::shared_ptr<IAuthGraphKeyExchange> sink = authNode_; |
| |
| SessionInitiationInfo source_init_info1; |
| ASSERT_EQ(OK, GetReturnError(source->create(&source_init_info1))); |
| SessionInitiationInfo source_init_info2; |
| ASSERT_EQ(OK, GetReturnError(source->create(&source_init_info2))); |
| |
| // Two calls to create() should result in the same identity but different nonce values. |
| ASSERT_EQ(source_init_info1.identity, source_init_info2.identity); |
| ASSERT_NE(source_init_info1.nonce, source_init_info2.nonce); |
| ASSERT_NE(source_init_info1.key.pubKey, source_init_info2.key.pubKey); |
| ASSERT_NE(source_init_info1.key.arcFromPBK, source_init_info2.key.arcFromPBK); |
| |
| KeInitResult init_result1; |
| ASSERT_EQ(OK, GetReturnError(sink->init(source_init_info1.key.pubKey.value(), |
| source_init_info1.identity, source_init_info1.nonce, |
| source_init_info1.version, &init_result1))); |
| KeInitResult init_result2; |
| ASSERT_EQ(OK, GetReturnError(sink->init(source_init_info2.key.pubKey.value(), |
| source_init_info2.identity, source_init_info2.nonce, |
| source_init_info2.version, &init_result2))); |
| |
| // Two calls to init() should result in the same identity buf different nonces and session IDs. |
| ASSERT_EQ(init_result1.sessionInitiationInfo.identity, |
| init_result2.sessionInitiationInfo.identity); |
| ASSERT_NE(init_result1.sessionInitiationInfo.nonce, init_result2.sessionInitiationInfo.nonce); |
| ASSERT_NE(init_result1.sessionInfo.sessionId, init_result2.sessionInfo.sessionId); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(PerInstance, AuthGraphSessionTest, |
| testing::ValuesIn(AuthGraphSessionTest::build_params()), |
| ::android::PrintInstanceNameToString); |
| GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(AuthGraphSessionTest); |
| |
| } // namespace aidl::android::hardware::security::authgraph::test |
| |
| int main(int argc, char** argv) { |
| ::testing::InitGoogleTest(&argc, argv); |
| return RUN_ALL_TESTS(); |
| } |
