tests/gatekeeper_messages_test.cpp - platform/system/gatekeeper - Git at Google

 /*
  * 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);
	/*
	* 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);