Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / system / gatekeeper / 6c9fe69766c5a8f0a7d5bd91ac465c625e64b474 / . / tests / keyguard_messages_test.cpp
blob: 77fbb99f6301a5d89dae417010f713005c88a255 [file] [log] [blame]
Andres Morales6c9fe692015-02-23 10:44:41 -0800[diff] [blame^]1/*
2 * Copyright (C) 2015 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 <gtest/gtest.h>
18#include <string.h>
19#include <stdlib.h>
20#include <stdio.h>
21
22#include <keyguard/keyguard_messages.h>
23
24using ::keyguard::SizedBuffer;
25using ::testing::Test;
26using ::keyguard::EnrollRequest;
27using ::keyguard::EnrollResponse;
28using ::keyguard::VerifyRequest;
29using ::keyguard::VerifyResponse;
30using std::cout;
31using std::endl;
32
33static SizedBuffer *make_buffer(size_t size) {
34 SizedBuffer *result = new SizedBuffer;
35 result->length = size;
36 uint8_t *buffer = new uint8_t[size];
37 srand(size);
38
39 for (size_t i = 0; i < size; i++) {
40 buffer[i] = rand();
41 }
42
43 result->buffer.reset(buffer);
44 return result;
45}
46
47TEST(RoundTripTest, EnrollRequest) {
48 const size_t password_size = 512;
49 SizedBuffer *provided_password = make_buffer(password_size);
50 const SizedBuffer *deserialized_password;
51 // create request, serialize, deserialize, and validate
52 EnrollRequest req(provided_password);
53 uint8_t *serialized_req = req.Serialize();
54 EnrollRequest deserialized_req;
55 deserialized_req.Deserialize(serialized_req, serialized_req + req.GetSerializedSize());
56 delete[] serialized_req;
57
58 ASSERT_EQ(keyguard::keyguard_error_t::KG_ERROR_OK,
59 deserialized_req.GetError());
60
61 deserialized_password = deserialized_req.GetProvidedPassword();
62 ASSERT_EQ((uint32_t) password_size, deserialized_password->length);
63 ASSERT_EQ(0, memcmp(req.GetProvidedPassword()->buffer.get(), deserialized_password->buffer.get(), password_size));
64}
65
66TEST(RoundTripTest, EnrollResponse) {
67 const size_t password_size = 512;
68 SizedBuffer *enrolled_password = make_buffer(password_size);
69 const SizedBuffer *deserialized_password;
70 // create request, serialize, deserialize, and validate
71 EnrollResponse req(enrolled_password);
72 uint8_t *serialized_req = req.Serialize();
73 EnrollResponse deserialized_req;
74 deserialized_req.Deserialize(serialized_req, serialized_req + req.GetSerializedSize());
75 delete[] serialized_req;
76
77 ASSERT_EQ(keyguard::keyguard_error_t::KG_ERROR_OK,
78 deserialized_req.GetError());
79
80 deserialized_password = deserialized_req.GetEnrolledPasswordHandle();
81 ASSERT_EQ((uint32_t) password_size, deserialized_password->length);
82 ASSERT_EQ(0, memcmp(req.GetEnrolledPasswordHandle()->buffer.get(), deserialized_password->buffer.get(), password_size));
83}
84
85TEST(RoundTripTest, VerifyRequest) {
86 const size_t password_size = 1;
87 SizedBuffer *provided_password = make_buffer(password_size),
88 *password_handle = make_buffer(password_size);
89 const SizedBuffer *deserialized_password;
90 // create request, serialize, deserialize, and validate
91 VerifyRequest req(password_handle, provided_password);
92 uint8_t *serialized_req = req.Serialize();
93 VerifyRequest deserialized_req;
94 deserialized_req.Deserialize(serialized_req, serialized_req + req.GetSerializedSize());
95
96 ASSERT_EQ(keyguard::keyguard_error_t::KG_ERROR_OK,
97 deserialized_req.GetError());
98
99 deserialized_password = deserialized_req.GetProvidedPassword();
100 ASSERT_EQ((uint32_t) password_size, deserialized_password->length);
101 ASSERT_EQ(0, memcmp(req.GetProvidedPassword()->buffer.get(), deserialized_password->buffer.get(), password_size));
102
103 deserialized_password = deserialized_req.GetPasswordHandle();
104 ASSERT_EQ((uint32_t) password_size, deserialized_password->length);
105 ASSERT_EQ(0, memcmp(req.GetPasswordHandle()->buffer.get(), deserialized_password->buffer.get(), password_size));
106}
107
108TEST(RoundTripTest, VerifyResponse) {
109 const size_t password_size = 512;
110 SizedBuffer *verification_token = make_buffer(password_size);
111 const SizedBuffer *deserialized_password;
112 // create request, serialize, deserialize, and validate
113 VerifyResponse req(verification_token);
114 uint8_t *serialized_req = req.Serialize();
115 VerifyResponse deserialized_req;
116 deserialized_req.Deserialize(serialized_req, serialized_req + req.GetSerializedSize());
117 delete[] serialized_req;
118
119 ASSERT_EQ(keyguard::keyguard_error_t::KG_ERROR_OK,
120 deserialized_req.GetError());
121
122 deserialized_password = deserialized_req.GetVerificationToken();
123 ASSERT_EQ((uint32_t) password_size, deserialized_password->length);
124 ASSERT_EQ(0, memcmp(req.GetVerificationToken()->buffer.get(), deserialized_password->buffer.get(), password_size));
125}
126
127uint8_t msgbuf[] = {
128 220, 88, 183, 255, 71, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
129 0, 173, 0, 0, 0, 228, 174, 98, 187, 191, 135, 253, 200, 51, 230, 114, 247, 151, 109,
130 237, 79, 87, 32, 94, 5, 204, 46, 154, 30, 91, 6, 103, 148, 254, 129, 65, 171, 228,
131 167, 224, 163, 9, 15, 206, 90, 58, 11, 205, 55, 211, 33, 87, 178, 149, 91, 28, 236,
132 218, 112, 231, 34, 82, 82, 134, 103, 137, 115, 27, 156, 102, 159, 220, 226, 89, 42, 25,
133 37, 9, 84, 239, 76, 161, 198, 72, 167, 163, 39, 91, 148, 191, 17, 191, 87, 169, 179,
134 136, 10, 194, 154, 4, 40, 107, 109, 61, 161, 20, 176, 247, 13, 214, 106, 229, 45, 17,
135 5, 60, 189, 64, 39, 166, 208, 14, 57, 25, 140, 148, 25, 177, 246, 189, 43, 181, 88,
136 204, 29, 126, 224, 100, 143, 93, 60, 57, 249, 55, 0, 87, 83, 227, 224, 166, 59, 214,
137 81, 144, 129, 58, 6, 57, 46, 254, 232, 41, 220, 209, 230, 167, 138, 158, 94, 180, 125,
138 247, 26, 162, 116, 238, 202, 187, 100, 65, 13, 180, 44, 245, 159, 83, 161, 176, 58, 72,
139 236, 109, 105, 160, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
140 0, 11, 0, 0, 0, 98, 0, 0, 0, 1, 0, 0, 32, 2, 0, 0, 0, 1, 0,
141 0, 32, 3, 0, 0, 0, 2, 0, 0, 16, 1, 0, 0, 0, 3, 0, 0, 48, 0,
142 1, 0, 0, 200, 0, 0, 80, 3, 0, 0, 0, 0, 0, 0, 0, 244, 1, 0, 112,
143 1, 246, 1, 0, 112, 1, 189, 2, 0, 96, 144, 178, 236, 250, 255, 255, 255, 255, 145,
144 1, 0, 96, 144, 226, 33, 60, 222, 2, 0, 0, 189, 2, 0, 96, 0, 0, 0, 0,
145 0, 0, 0, 0, 190, 2, 0, 16, 1, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0,
146 0, 0, 0, 0, 0, 0, 0, 0, 0, 110, 0, 0, 0, 0, 0, 0, 0, 11, 0,
147 0, 0, 98, 0, 0, 0, 1, 0, 0, 32, 2, 0, 0, 0, 1, 0, 0, 32, 3,
148 0, 0, 0, 2, 0, 0, 16, 1, 0, 0, 0, 3, 0, 0, 48, 0, 1, 0, 0,
149 200, 0, 0, 80, 3, 0, 0, 0, 0, 0, 0, 0, 244, 1, 0, 112, 1, 246, 1,
150 0, 112, 1, 189, 2, 0, 96, 144, 178, 236, 250, 255, 255, 255, 255, 145, 1, 0, 96,
151 144, 226, 33, 60, 222, 2, 0, 0, 189, 2, 0, 96, 0, 0, 0, 0, 0, 0, 0,
152 0, 190, 2, 0, 16, 1, 0, 0, 0,
153};
154
155
156/*
157 * These tests don't have any assertions or expectations. They just try to parse garbage, to see if
158 * the result will be a crash. This is especially informative when run under Valgrind memcheck.
159 */
160
161template <typename Message> void parse_garbage() {
162 Message msg;
163 size_t array_length = sizeof(msgbuf) / sizeof(msgbuf[0]);
164 const uint8_t* end = msgbuf + array_length;
165 for (size_t i = 0; i < array_length; ++i) {
166 const uint8_t* begin = msgbuf + i;
167 const uint8_t* p = begin;
168 msg.Deserialize(p, end);
169 }
170}
171
172#define GARBAGE_TEST(Message) \
173 TEST(GarbageTest, Message) { parse_garbage<Message>(); }
174
175GARBAGE_TEST(VerifyRequest);
176GARBAGE_TEST(VerifyResponse);
177GARBAGE_TEST(EnrollRequest);
178GARBAGE_TEST(EnrollResponse);