You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
300 lines
14 KiB
300 lines
14 KiB
/*
|
|
* Copyright (C) 2015 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.
|
|
*/
|
|
|
|
#include <gtest/gtest.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
|
|
#include <gatekeeper/gatekeeper_messages.h>
|
|
|
|
#include <vector>
|
|
|
|
using ::gatekeeper::SizedBuffer;
|
|
using ::testing::Test;
|
|
using ::gatekeeper::EnrollRequest;
|
|
using ::gatekeeper::EnrollResponse;
|
|
using ::gatekeeper::VerifyRequest;
|
|
using ::gatekeeper::VerifyResponse;
|
|
using std::cout;
|
|
using std::endl;
|
|
|
|
static const uint32_t USER_ID = 3857;
|
|
|
|
static SizedBuffer make_buffer(uint32_t size) {
|
|
uint8_t *buffer = new uint8_t[size];
|
|
srand(size);
|
|
|
|
for (uint32_t i = 0; i < size; i++) {
|
|
buffer[i] = rand();
|
|
}
|
|
|
|
return { buffer, size };
|
|
}
|
|
|
|
TEST(RoundTripTest, EnrollRequestNullEnrolledNullHandle) {
|
|
const uint32_t password_size = 512;
|
|
const SizedBuffer *deserialized_password;
|
|
// create request, serialize, deserialize, and validate
|
|
EnrollRequest msg(USER_ID, {}, make_buffer(password_size), {});
|
|
|
|
std::vector<uint8_t> serialized_msg(msg.GetSerializedSize());
|
|
ASSERT_EQ(serialized_msg.size(), msg.Serialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
|
|
EnrollRequest deserialized_msg;
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_NONE,
|
|
deserialized_msg.Deserialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_NONE,
|
|
deserialized_msg.error);
|
|
|
|
deserialized_password = &deserialized_msg.provided_password;
|
|
ASSERT_EQ(USER_ID, deserialized_msg.user_id);
|
|
ASSERT_EQ((uint32_t) password_size, deserialized_password->size());
|
|
ASSERT_EQ(0, memcmp(msg.provided_password.Data<uint8_t>(), deserialized_password->Data<uint8_t>(), password_size));
|
|
ASSERT_FALSE(deserialized_msg.enrolled_password);
|
|
ASSERT_FALSE(deserialized_msg.password_handle);
|
|
}
|
|
|
|
TEST(RoundTripTest, EnrollRequestEmptyEnrolledEmptyHandle) {
|
|
const uint32_t password_size = 512;
|
|
const SizedBuffer *deserialized_password;
|
|
// create request, serialize, deserialize, and validate
|
|
EnrollRequest msg(USER_ID, {}, make_buffer(password_size), {});
|
|
std::vector<uint8_t> serialized_msg(msg.GetSerializedSize());
|
|
ASSERT_EQ(serialized_msg.size(), msg.Serialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
|
|
EnrollRequest deserialized_msg;
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_NONE,
|
|
deserialized_msg.Deserialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_NONE,
|
|
deserialized_msg.error);
|
|
|
|
deserialized_password = &deserialized_msg.provided_password;
|
|
ASSERT_EQ(USER_ID, deserialized_msg.user_id);
|
|
ASSERT_EQ((uint32_t) password_size, deserialized_password->size());
|
|
ASSERT_EQ(0, memcmp(msg.provided_password.Data<uint8_t>(), deserialized_password->Data<uint8_t>(), password_size));
|
|
ASSERT_FALSE(deserialized_msg.enrolled_password);
|
|
ASSERT_FALSE(deserialized_msg.password_handle);
|
|
}
|
|
|
|
TEST(RoundTripTest, EnrollRequestNonNullEnrolledOrHandle) {
|
|
const uint32_t password_size = 512;
|
|
SizedBuffer provided_password = make_buffer(password_size);
|
|
SizedBuffer enrolled_password = make_buffer(password_size);
|
|
SizedBuffer password_handle = make_buffer(password_size);
|
|
const SizedBuffer *deserialized_password;
|
|
const SizedBuffer *deserialized_enrolled;
|
|
const SizedBuffer *deserialized_handle;
|
|
// create request, serialize, deserialize, and validate
|
|
EnrollRequest msg(USER_ID, move(password_handle), move(provided_password), move(enrolled_password));
|
|
std::vector<uint8_t> serialized_msg(msg.GetSerializedSize());
|
|
ASSERT_EQ(serialized_msg.size(), msg.Serialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
|
|
EnrollRequest deserialized_msg;
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_NONE,
|
|
deserialized_msg.Deserialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_NONE,
|
|
deserialized_msg.error);
|
|
|
|
deserialized_password = &deserialized_msg.provided_password;
|
|
deserialized_enrolled = &deserialized_msg.enrolled_password;
|
|
deserialized_handle = &deserialized_msg.password_handle;
|
|
ASSERT_EQ(USER_ID, deserialized_msg.user_id);
|
|
ASSERT_EQ((uint32_t) password_size, deserialized_password->size());
|
|
ASSERT_EQ(0, memcmp(msg.provided_password.Data<uint8_t>(), deserialized_password->Data<uint8_t>(), password_size));
|
|
ASSERT_EQ((uint32_t) password_size, deserialized_enrolled->size());
|
|
ASSERT_EQ(0, memcmp(msg.enrolled_password.Data<uint8_t>(), deserialized_enrolled->Data<uint8_t>(), password_size));
|
|
ASSERT_EQ((uint32_t) password_size, deserialized_handle->size());
|
|
ASSERT_EQ(0, memcmp(msg.password_handle.Data<uint8_t>(), deserialized_handle->Data<uint8_t>(), password_size));
|
|
}
|
|
|
|
|
|
TEST(RoundTripTest, EnrollResponse) {
|
|
const uint32_t password_size = 512;
|
|
const SizedBuffer *deserialized_password;
|
|
// create request, serialize, deserialize, and validate
|
|
EnrollResponse msg(USER_ID, make_buffer(password_size));
|
|
std::vector<uint8_t> serialized_msg(msg.GetSerializedSize());
|
|
ASSERT_EQ(serialized_msg.size(), msg.Serialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
|
|
EnrollResponse deserialized_msg;
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_NONE,
|
|
deserialized_msg.Deserialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_NONE,
|
|
deserialized_msg.error);
|
|
|
|
deserialized_password = &deserialized_msg.enrolled_password_handle;
|
|
ASSERT_EQ(USER_ID, deserialized_msg.user_id);
|
|
ASSERT_EQ((uint32_t) password_size, deserialized_password->size());
|
|
ASSERT_EQ(0, memcmp(msg.enrolled_password_handle.Data<uint8_t>(),
|
|
deserialized_password->Data<uint8_t>(), password_size));
|
|
}
|
|
|
|
TEST(RoundTripTest, VerifyRequest) {
|
|
const uint32_t password_size = 512;
|
|
const SizedBuffer *deserialized_password;
|
|
// create request, serialize, deserialize, and validate
|
|
VerifyRequest msg(USER_ID, 1, make_buffer(password_size), make_buffer(password_size));
|
|
std::vector<uint8_t> serialized_msg(msg.GetSerializedSize());
|
|
ASSERT_EQ(serialized_msg.size(), msg.Serialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
|
|
VerifyRequest deserialized_msg;
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_NONE,
|
|
deserialized_msg.Deserialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_NONE,
|
|
deserialized_msg.error);
|
|
|
|
ASSERT_EQ(USER_ID, deserialized_msg.user_id);
|
|
ASSERT_EQ((uint64_t) 1, deserialized_msg.challenge);
|
|
deserialized_password = &deserialized_msg.password_handle;
|
|
ASSERT_EQ((uint32_t) password_size, deserialized_password->size());
|
|
ASSERT_EQ(0, memcmp(msg.provided_password.Data<uint8_t>(), deserialized_password->Data<uint8_t>(),
|
|
password_size));
|
|
|
|
deserialized_password = &deserialized_msg.password_handle;
|
|
ASSERT_EQ((uint32_t) password_size, deserialized_password->size());
|
|
ASSERT_EQ(0, memcmp(msg.password_handle.Data<uint8_t>(), deserialized_password->Data<uint8_t>(),
|
|
password_size));
|
|
}
|
|
|
|
TEST(RoundTripTest, VerifyResponse) {
|
|
const uint32_t password_size = 512;
|
|
const SizedBuffer *deserialized_password;
|
|
// create request, serialize, deserialize, and validate
|
|
VerifyResponse msg(USER_ID, make_buffer(password_size));
|
|
std::vector<uint8_t> serialized_msg(msg.GetSerializedSize());
|
|
ASSERT_EQ(serialized_msg.size(), msg.Serialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
|
|
VerifyResponse deserialized_msg;
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_NONE,
|
|
deserialized_msg.Deserialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_NONE,
|
|
deserialized_msg.error);
|
|
|
|
ASSERT_EQ(USER_ID, deserialized_msg.user_id);
|
|
deserialized_password = &deserialized_msg.auth_token;
|
|
ASSERT_EQ((uint32_t) password_size, deserialized_password->size());
|
|
ASSERT_EQ(0, memcmp(msg.auth_token.Data<uint8_t>(), deserialized_password->Data<uint8_t>(),
|
|
password_size));
|
|
}
|
|
|
|
TEST(RoundTripTest, VerifyResponseError) {
|
|
VerifyResponse msg;
|
|
msg.error = gatekeeper::gatekeeper_error_t::ERROR_INVALID;
|
|
std::vector<uint8_t> serialized_msg(msg.GetSerializedSize());
|
|
ASSERT_EQ(serialized_msg.size(), msg.Serialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
VerifyResponse deserialized_msg;
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_NONE,
|
|
deserialized_msg.Deserialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_INVALID,
|
|
deserialized_msg.error);
|
|
}
|
|
|
|
TEST(RoundTripTest, VerifyRequestError) {
|
|
VerifyRequest msg;
|
|
msg.error = gatekeeper::gatekeeper_error_t::ERROR_INVALID;
|
|
std::vector<uint8_t> serialized_msg(msg.GetSerializedSize());
|
|
ASSERT_EQ(serialized_msg.size(), msg.Serialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
VerifyRequest deserialized_msg;
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_NONE,
|
|
deserialized_msg.Deserialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_INVALID,
|
|
deserialized_msg.error);
|
|
}
|
|
|
|
TEST(RoundTripTest, EnrollResponseError) {
|
|
EnrollResponse msg;
|
|
msg.error = gatekeeper::gatekeeper_error_t::ERROR_INVALID;
|
|
std::vector<uint8_t> serialized_msg(msg.GetSerializedSize());
|
|
ASSERT_EQ(serialized_msg.size(), msg.Serialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
EnrollResponse deserialized_msg;
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_NONE,
|
|
deserialized_msg.Deserialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_INVALID,
|
|
deserialized_msg.error);
|
|
}
|
|
|
|
TEST(RoundTripTest, EnrollRequestError) {
|
|
EnrollRequest msg;
|
|
msg.error = gatekeeper::gatekeeper_error_t::ERROR_INVALID;
|
|
std::vector<uint8_t> serialized_msg(msg.GetSerializedSize());
|
|
ASSERT_EQ(serialized_msg.size(), msg.Serialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
EnrollRequest deserialized_msg;
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_NONE,
|
|
deserialized_msg.Deserialize(&*serialized_msg.begin(), &*serialized_msg.end()));
|
|
ASSERT_EQ(gatekeeper::gatekeeper_error_t::ERROR_INVALID,
|
|
deserialized_msg.error);
|
|
}
|
|
|
|
uint8_t msgbuf[] = {
|
|
220, 88, 183, 255, 71, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 173, 0, 0, 0, 228, 174, 98, 187, 191, 135, 253, 200, 51, 230, 114, 247, 151, 109,
|
|
237, 79, 87, 32, 94, 5, 204, 46, 154, 30, 91, 6, 103, 148, 254, 129, 65, 171, 228,
|
|
167, 224, 163, 9, 15, 206, 90, 58, 11, 205, 55, 211, 33, 87, 178, 149, 91, 28, 236,
|
|
218, 112, 231, 34, 82, 82, 134, 103, 137, 115, 27, 156, 102, 159, 220, 226, 89, 42, 25,
|
|
37, 9, 84, 239, 76, 161, 198, 72, 167, 163, 39, 91, 148, 191, 17, 191, 87, 169, 179,
|
|
136, 10, 194, 154, 4, 40, 107, 109, 61, 161, 20, 176, 247, 13, 214, 106, 229, 45, 17,
|
|
5, 60, 189, 64, 39, 166, 208, 14, 57, 25, 140, 148, 25, 177, 246, 189, 43, 181, 88,
|
|
204, 29, 126, 224, 100, 143, 93, 60, 57, 249, 55, 0, 87, 83, 227, 224, 166, 59, 214,
|
|
81, 144, 129, 58, 6, 57, 46, 254, 232, 41, 220, 209, 230, 167, 138, 158, 94, 180, 125,
|
|
247, 26, 162, 116, 238, 202, 187, 100, 65, 13, 180, 44, 245, 159, 83, 161, 176, 58, 72,
|
|
236, 109, 105, 160, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 11, 0, 0, 0, 98, 0, 0, 0, 1, 0, 0, 32, 2, 0, 0, 0, 1, 0,
|
|
0, 32, 3, 0, 0, 0, 2, 0, 0, 16, 1, 0, 0, 0, 3, 0, 0, 48, 0,
|
|
1, 0, 0, 200, 0, 0, 80, 3, 0, 0, 0, 0, 0, 0, 0, 244, 1, 0, 112,
|
|
1, 246, 1, 0, 112, 1, 189, 2, 0, 96, 144, 178, 236, 250, 255, 255, 255, 255, 145,
|
|
1, 0, 96, 144, 226, 33, 60, 222, 2, 0, 0, 189, 2, 0, 96, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 190, 2, 0, 16, 1, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 110, 0, 0, 0, 0, 0, 0, 0, 11, 0,
|
|
0, 0, 98, 0, 0, 0, 1, 0, 0, 32, 2, 0, 0, 0, 1, 0, 0, 32, 3,
|
|
0, 0, 0, 2, 0, 0, 16, 1, 0, 0, 0, 3, 0, 0, 48, 0, 1, 0, 0,
|
|
200, 0, 0, 80, 3, 0, 0, 0, 0, 0, 0, 0, 244, 1, 0, 112, 1, 246, 1,
|
|
0, 112, 1, 189, 2, 0, 96, 144, 178, 236, 250, 255, 255, 255, 255, 145, 1, 0, 96,
|
|
144, 226, 33, 60, 222, 2, 0, 0, 189, 2, 0, 96, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 190, 2, 0, 16, 1, 0, 0, 0,
|
|
};
|
|
|
|
|
|
/*
|
|
* These tests don't have any assertions or expectations. They just try to parse garbage, to see if
|
|
* the result will be a crash. This is especially informative when run under Valgrind memcheck.
|
|
*/
|
|
|
|
template <typename Message> void parse_garbage() {
|
|
Message msg;
|
|
uint32_t array_length = sizeof(msgbuf) / sizeof(msgbuf[0]);
|
|
const uint8_t* end = msgbuf + array_length;
|
|
for (uint32_t i = 0; i < array_length; ++i) {
|
|
const uint8_t* begin = msgbuf + i;
|
|
const uint8_t* p = begin;
|
|
msg.Deserialize(p, end);
|
|
}
|
|
}
|
|
|
|
#define GARBAGE_TEST(Message) \
|
|
TEST(GarbageTest, Message) { parse_garbage<Message>(); }
|
|
|
|
GARBAGE_TEST(VerifyRequest);
|
|
GARBAGE_TEST(VerifyResponse);
|
|
GARBAGE_TEST(EnrollRequest);
|
|
GARBAGE_TEST(EnrollResponse);
|