1 #include <android/binder_manager.h>
2 #include <gtest/gtest.h>
3 #include <linux/dma-heap.h>
4 #include <sys/auxv.h>
5 #include <sys/mman.h>
6 #include "hwcryptokeyimpl.h"
7
align_overflow(size_t size,size_t alignment,size_t * aligned)8 static inline bool align_overflow(size_t size, size_t alignment, size_t* aligned) {
9 if (size % alignment == 0) {
10 *aligned = size;
11 return false;
12 }
13 size_t temp = 0;
14 bool overflow = __builtin_add_overflow(size / alignment, 1, &temp);
15 overflow |= __builtin_mul_overflow(temp, alignment, aligned);
16 return overflow;
17 }
18
allocate_buffers(size_t size)19 static int allocate_buffers(size_t size) {
20 const char* device_name = "/dev/dma_heap/system";
21 int dma_heap_fd = open(device_name, O_RDONLY | O_CLOEXEC);
22 if (dma_heap_fd < 0) {
23 LOG(ERROR) << "Cannot open " << device_name;
24 return -1;
25 }
26 size_t aligned = 0;
27 if (align_overflow(size, getauxval(AT_PAGESZ), &aligned)) {
28 LOG(ERROR) << "Rounding up buffer size oveflowed";
29 return -1;
30 }
31 struct dma_heap_allocation_data allocation_request = {
32 .len = aligned,
33 .fd_flags = O_RDWR | O_CLOEXEC,
34 };
35 int rc = ioctl(dma_heap_fd, DMA_HEAP_IOCTL_ALLOC, &allocation_request);
36 if (rc < 0) {
37 LOG(ERROR) << "Buffer allocation request failed " << rc;
38 return -1;
39 }
40 int fd = allocation_request.fd;
41 if (fd < 0) {
42 LOG(ERROR) << "Allocation request returned bad fd" << fd;
43 return -1;
44 }
45 return fd;
46 }
47
main(int argc,char ** argv)48 int main(int argc, char** argv) {
49 ::testing::InitGoogleTest(&argc, argv);
50 return RUN_ALL_TESTS();
51 }
52
TEST(HwCryptoHalDelegator,FdTest)53 TEST(HwCryptoHalDelegator, FdTest) {
54 const std::string instance =
55 std::string() + ndk_hwcrypto::IHwCryptoKey::descriptor + "/default";
56 ndk::SpAIBinder binder(AServiceManager_waitForService(instance.c_str()));
57 ASSERT_NE(binder, nullptr);
58 auto hwCryptoKey = ndk_hwcrypto::IHwCryptoKey::fromBinder(binder);
59 ASSERT_NE(hwCryptoKey, nullptr);
60 auto fd = allocate_buffers(4096);
61 EXPECT_GE(fd, 0);
62 ndk::ScopedFileDescriptor ndkFd(fd);
63 ndk_hwcrypto::MemoryBufferParameter memBuffParam = ndk_hwcrypto::MemoryBufferParameter();
64 memBuffParam.bufferHandle.set<ndk_hwcrypto::MemoryBufferParameter::MemoryBuffer::input>(
65 std::move(ndkFd));
66 memBuffParam.sizeBytes = 4096;
67 auto operation = ndk_hwcrypto::CryptoOperation();
68 operation.set<ndk_hwcrypto::CryptoOperation::setMemoryBuffer>(std::move(memBuffParam));
69 ndk_hwcrypto::CryptoOperationSet operationSet = ndk_hwcrypto::CryptoOperationSet();
70 operationSet.context = nullptr;
71 operationSet.operations.push_back(std::move(operation));
72 std::vector<ndk_hwcrypto::CryptoOperationSet> operationSets;
73 operationSets.push_back(std::move(operationSet));
74 std::vector<ndk_hwcrypto::CryptoOperationResult> aidl_return;
75 std::shared_ptr<ndk_hwcrypto::IHwCryptoOperations> hwCryptoOperations;
76 auto res = hwCryptoKey->getHwCryptoOperations(&hwCryptoOperations);
77 EXPECT_TRUE(res.isOk());
78 res = hwCryptoOperations->processCommandList(&operationSets, &aidl_return);
79 EXPECT_TRUE(res.isOk());
80 }
81
TEST(HwCryptoHalDelegator,keyPolicyCppToNdk)82 TEST(HwCryptoHalDelegator, keyPolicyCppToNdk) {
83 cpp_hwcrypto::KeyPolicy cppPolicy = cpp_hwcrypto::KeyPolicy();
84 cppPolicy.keyType = cpp_hwcrypto::types::KeyType::AES_128_CBC_PKCS7_PADDING;
85 cppPolicy.usage = cpp_hwcrypto::types::KeyUse::DECRYPT;
86 cppPolicy.keyLifetime = cpp_hwcrypto::types::KeyLifetime::PORTABLE;
87 cppPolicy.keyManagementKey = false;
88 cppPolicy.keyPermissions.push_back(
89 cpp_hwcrypto::types::KeyPermissions::ALLOW_PORTABLE_KEY_WRAPPING);
90 ndk_hwcrypto::KeyPolicy ndkPolicy = android::trusty::hwcryptohalservice::convertKeyPolicy<
91 ndk_hwcrypto::KeyPolicy, cpp_hwcrypto::KeyPolicy>(cppPolicy);
92 EXPECT_EQ(ndkPolicy.keyType, ndk_hwcrypto::types::KeyType::AES_128_CBC_PKCS7_PADDING);
93 EXPECT_EQ(ndkPolicy.usage, ndk_hwcrypto::types::KeyUse::DECRYPT);
94 EXPECT_EQ(ndkPolicy.keyLifetime, ndk_hwcrypto::types::KeyLifetime::PORTABLE);
95 EXPECT_EQ(ndkPolicy.keyManagementKey, false);
96 EXPECT_EQ(ndkPolicy.keyPermissions.size(), 1ul);
97 EXPECT_EQ(ndkPolicy.keyPermissions[0],
98 ndk_hwcrypto::types::KeyPermissions::ALLOW_PORTABLE_KEY_WRAPPING);
99 }
100
TEST(HwCryptoHalDelegator,keyPolicyNdkToCpp)101 TEST(HwCryptoHalDelegator, keyPolicyNdkToCpp) {
102 ndk_hwcrypto::KeyPolicy ndkPolicy = ndk_hwcrypto::KeyPolicy();
103 ndkPolicy.keyType = ndk_hwcrypto::types::KeyType::AES_128_CTR;
104 ndkPolicy.usage = ndk_hwcrypto::types::KeyUse::ENCRYPT_DECRYPT;
105 ndkPolicy.keyLifetime = ndk_hwcrypto::types::KeyLifetime::HARDWARE;
106 ndkPolicy.keyManagementKey = true;
107 ndkPolicy.keyPermissions.push_back(
108 ndk_hwcrypto::types::KeyPermissions::ALLOW_EPHEMERAL_KEY_WRAPPING);
109 ndkPolicy.keyPermissions.push_back(
110 ndk_hwcrypto::types::KeyPermissions::ALLOW_HARDWARE_KEY_WRAPPING);
111 cpp_hwcrypto::KeyPolicy cppPolicy = android::trusty::hwcryptohalservice::convertKeyPolicy<
112 cpp_hwcrypto::KeyPolicy, ndk_hwcrypto::KeyPolicy>(ndkPolicy);
113 EXPECT_EQ(cppPolicy.keyType, cpp_hwcrypto::types::KeyType::AES_128_CTR);
114 EXPECT_EQ(cppPolicy.usage, cpp_hwcrypto::types::KeyUse::ENCRYPT_DECRYPT);
115 EXPECT_EQ(cppPolicy.keyLifetime, cpp_hwcrypto::types::KeyLifetime::HARDWARE);
116 EXPECT_EQ(cppPolicy.keyManagementKey, true);
117 EXPECT_EQ(cppPolicy.keyPermissions.size(), 2ul);
118 EXPECT_EQ(cppPolicy.keyPermissions[0],
119 cpp_hwcrypto::types::KeyPermissions::ALLOW_EPHEMERAL_KEY_WRAPPING);
120 EXPECT_EQ(cppPolicy.keyPermissions[1],
121 cpp_hwcrypto::types::KeyPermissions::ALLOW_HARDWARE_KEY_WRAPPING);
122 }
123