android_keymaster_messages_test.cpp revision 58e1a5486219a1be9264d4e863a9dd3e393906c3 
1/*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <UniquePtr.h>
18
19#include <gtest/gtest.h>
20
21#define KEYMASTER_NAME_TAGS
22#include "keymaster_tags.h"
23#include "google_keymaster_utils.h"
24#include "google_softkeymaster.h"
25
26int main(int argc, char** argv) {
27    ::testing::InitGoogleTest(&argc, argv);
28    int result = RUN_ALL_TESTS();
29    return result;
30}
31
32namespace keymaster {
33namespace test {
34
35TEST(GenerateKeyRequest, RoundTrip) {
36    keymaster_key_param_t params[] = {
37        Authorization(TAG_PURPOSE, KM_PURPOSE_SIGN),
38        Authorization(TAG_PURPOSE, KM_PURPOSE_VERIFY),
39        Authorization(TAG_ALGORITHM, KM_ALGORITHM_RSA),
40        Authorization(TAG_USER_ID, 7),
41        Authorization(TAG_USER_AUTH_ID, 8),
42        Authorization(TAG_APPLICATION_ID, "app_id", 6),
43        Authorization(TAG_AUTH_TIMEOUT, 300),
44    };
45    GenerateKeyRequest req;
46    req.key_description.Reinitialize(params, array_length(params));
47
48    size_t size = req.SerializedSize();
49    EXPECT_EQ(182U, size);
50
51    UniquePtr<uint8_t[]> buf(new uint8_t[size]);
52    EXPECT_EQ(buf.get() + size, req.Serialize(buf.get(), buf.get() + size));
53
54    GenerateKeyRequest deserialized1;
55    const uint8_t* p = buf.get();
56    EXPECT_TRUE(deserialized1.Deserialize(&p, p + size));
57    EXPECT_EQ(7U, deserialized1.key_description.size());
58
59    // Check a few entries.
60    keymaster_purpose_t purpose;
61    EXPECT_TRUE(deserialized1.key_description.GetTagValue(TAG_PURPOSE, 0, &purpose));
62    EXPECT_EQ(KM_PURPOSE_SIGN, purpose);
63    keymaster_blob_t blob;
64    EXPECT_TRUE(deserialized1.key_description.GetTagValue(TAG_APPLICATION_ID, &blob));
65    EXPECT_EQ(6U, blob.data_length);
66    EXPECT_EQ(0, memcmp(blob.data, "app_id", 6));
67    uint32_t val;
68    EXPECT_TRUE(deserialized1.key_description.GetTagValue(TAG_USER_ID, &val));
69    EXPECT_EQ(7U, val);
70
71    GenerateKeyRequest deserialized2;
72    const uint8_t* p2 = buf.get();
73    EXPECT_TRUE(deserialized2.Deserialize(&p2, p2 + size));
74    EXPECT_EQ(7U, deserialized2.key_description.size());
75
76    // Check a few entries.
77    EXPECT_TRUE(deserialized2.key_description.GetTagValue(TAG_PURPOSE, 0, &purpose));
78    EXPECT_EQ(KM_PURPOSE_SIGN, purpose);
79    EXPECT_TRUE(deserialized2.key_description.GetTagValue(TAG_APPLICATION_ID, &blob));
80    EXPECT_EQ(6U, blob.data_length);
81    EXPECT_EQ(0, memcmp(blob.data, "app_id", 6));
82    EXPECT_TRUE(deserialized2.key_description.GetTagValue(TAG_USER_ID, &val));
83    EXPECT_EQ(7U, val);
84}
85
86uint8_t TEST_DATA[] = "a key blob";
87
88TEST(GenerateKeyResponse, RoundTrip) {
89    keymaster_key_param_t params[] = {
90        Authorization(TAG_PURPOSE, KM_PURPOSE_SIGN),
91        Authorization(TAG_PURPOSE, KM_PURPOSE_VERIFY),
92        Authorization(TAG_ALGORITHM, KM_ALGORITHM_RSA),
93        Authorization(TAG_USER_ID, 7),
94        Authorization(TAG_USER_AUTH_ID, 8),
95        Authorization(TAG_APPLICATION_ID, "app_id", 6),
96        Authorization(TAG_AUTH_TIMEOUT, 300),
97    };
98    GenerateKeyResponse rsp;
99    rsp.error = KM_ERROR_OK;
100    rsp.key_blob.key_material = dup_array(TEST_DATA);
101    rsp.key_blob.key_material_size = array_length(TEST_DATA);
102    rsp.enforced.Reinitialize(params, array_length(params));
103
104    size_t size = rsp.SerializedSize();
105    EXPECT_EQ(217U, size);
106
107    UniquePtr<uint8_t[]> buf(new uint8_t[size]);
108    EXPECT_EQ(buf.get() + size, rsp.Serialize(buf.get(), buf.get() + size));
109
110    GenerateKeyResponse deserialized;
111    const uint8_t* p = buf.get();
112    EXPECT_TRUE(deserialized.Deserialize(&p, p + size));
113    EXPECT_EQ(7U, deserialized.enforced.size());
114
115    EXPECT_EQ(0U, deserialized.unenforced.size());
116    EXPECT_EQ(KM_ERROR_OK, deserialized.error);
117
118    // Check a few entries of enforced.
119    keymaster_purpose_t purpose;
120    EXPECT_TRUE(deserialized.enforced.GetTagValue(TAG_PURPOSE, 0, &purpose));
121    EXPECT_EQ(KM_PURPOSE_SIGN, purpose);
122    keymaster_blob_t blob;
123    EXPECT_TRUE(deserialized.enforced.GetTagValue(TAG_APPLICATION_ID, &blob));
124    EXPECT_EQ(6U, blob.data_length);
125    EXPECT_EQ(0, memcmp(blob.data, "app_id", 6));
126    uint32_t val;
127    EXPECT_TRUE(deserialized.enforced.GetTagValue(TAG_USER_ID, &val));
128    EXPECT_EQ(7U, val);
129}
130
131TEST(GenerateKeyResponse, Error) {
132    keymaster_key_param_t params[] = {
133        Authorization(TAG_PURPOSE, KM_PURPOSE_SIGN),
134        Authorization(TAG_PURPOSE, KM_PURPOSE_VERIFY),
135        Authorization(TAG_ALGORITHM, KM_ALGORITHM_RSA),
136        Authorization(TAG_USER_ID, 7),
137        Authorization(TAG_USER_AUTH_ID, 8),
138        Authorization(TAG_APPLICATION_ID, "app_id", 6),
139        Authorization(TAG_AUTH_TIMEOUT, 300),
140    };
141    GenerateKeyResponse rsp;
142    rsp.error = KM_ERROR_UNSUPPORTED_ALGORITHM;
143    rsp.key_blob.key_material = dup_array(TEST_DATA);
144    rsp.key_blob.key_material_size = array_length(TEST_DATA);
145    rsp.enforced.Reinitialize(params, array_length(params));
146
147    size_t size = rsp.SerializedSize();
148    EXPECT_EQ(4U, size);
149
150    UniquePtr<uint8_t[]> buf(new uint8_t[size]);
151    EXPECT_EQ(buf.get() + size, rsp.Serialize(buf.get(), buf.get() + size));
152
153    GenerateKeyResponse deserialized;
154    const uint8_t* p = buf.get();
155    EXPECT_TRUE(deserialized.Deserialize(&p, p + size));
156    EXPECT_EQ(KM_ERROR_UNSUPPORTED_ALGORITHM, deserialized.error);
157    EXPECT_EQ(0U, deserialized.enforced.size());
158    EXPECT_EQ(0U, deserialized.unenforced.size());
159    EXPECT_EQ(0U, deserialized.key_blob.key_material_size);
160}
161
162}  // namespace test
163}  // namespace keymaster
164