gatekeeper_messages.cpp - platform/system/gatekeeper - Git at Google

 /*
  * Copyright 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 <gatekeeper/gatekeeper_messages.h>

 #include <string.h>

 namespace gatekeeper {

 /**
  * Methods for serializing/deserializing SizedBuffers
  */

 struct __attribute__((__packed__)) serial_header_t {
     uint32_t error;
     uint32_t user_id;
 };

 static inline bool fitsBuffer(const uint8_t* begin, const uint8_t* end, uint32_t field_size) {
     uintptr_t dummy;
     return !__builtin_add_overflow(reinterpret_cast<uintptr_t>(begin), field_size, &dummy)
             && dummy <= reinterpret_cast<uintptr_t>(end);
 }

 static inline uint32_t serialized_buffer_size(const SizedBuffer &buf) {
     return sizeof(decltype(buf.size())) + buf.size();
 }

 static inline void append_to_buffer(uint8_t **buffer, const SizedBuffer &to_append) {
     uint32_t length = to_append.size();
     memcpy(*buffer, &length, sizeof(length));
     *buffer += sizeof(length);
     if (length != 0 && to_append.Data<uint8_t>() != nullptr) {
         memcpy(*buffer, to_append.Data<uint8_t>(), length);
         *buffer += length;
     }
 }

 static inline gatekeeper_error_t read_from_buffer(const uint8_t **buffer, const uint8_t *end,
         SizedBuffer *target) {
     if (target == nullptr) return ERROR_INVALID;
     if (!fitsBuffer(*buffer, end, sizeof(uint32_t))) return ERROR_INVALID;

     // read length from incomming buffer
     uint32_t length;
     memcpy(&length, *buffer, sizeof(length));
     // advance out buffer
     *buffer += sizeof(length);

     if (length == 0) {
         *target = {};
     } else {
         // sanitize incoming buffer size
         if (!fitsBuffer(*buffer, end, length)) return ERROR_INVALID;

         uint8_t *target_buffer = new(std::nothrow) uint8_t[length];
         if (target_buffer == nullptr) return ERROR_MEMORY_ALLOCATION_FAILED;

         memcpy(target_buffer, *buffer, length);
         *buffer += length;
         *target = { target_buffer, length };
     }
     return ERROR_NONE;
 }


 uint32_t GateKeeperMessage::GetSerializedSize() const {
     if (error == ERROR_NONE) {
         uint32_t size = sizeof(serial_header_t) + nonErrorSerializedSize();
         return size;
     } else {
         uint32_t size = sizeof(serial_header_t);
         if (error == ERROR_RETRY) {
             size += sizeof(retry_timeout);
         }
         return size;
     }
 }

 uint32_t GateKeeperMessage::Serialize(uint8_t *buffer, const uint8_t *end) const {
     uint32_t bytes_written = 0;
     if (!fitsBuffer(buffer, end, GetSerializedSize())) {
         return 0;
     }

     serial_header_t *header = reinterpret_cast<serial_header_t *>(buffer);
     if (!fitsBuffer(buffer, end, sizeof(serial_header_t))) return 0;
     header->error = error;
     header->user_id = user_id;
     bytes_written += sizeof(*header);
     buffer += sizeof(*header);
     if (error == ERROR_RETRY) {
         if (!fitsBuffer(buffer, end, sizeof(retry_timeout))) return 0;
         memcpy(buffer, &retry_timeout, sizeof(retry_timeout));
         bytes_written  += sizeof(retry_timeout);
     } else if (error == ERROR_NONE) {
         uint32_t serialized_size = nonErrorSerializedSize();
         if (!fitsBuffer(buffer, end, serialized_size)) return 0;
         nonErrorSerialize(buffer);
         bytes_written += serialized_size;
     }
     return bytes_written;
 }

 gatekeeper_error_t GateKeeperMessage::Deserialize(const uint8_t *payload, const uint8_t *end) {
     if (!fitsBuffer(payload, end, sizeof(serial_header_t))) return ERROR_INVALID;
     const serial_header_t *header = reinterpret_cast<const serial_header_t *>(payload);
     error = static_cast<gatekeeper_error_t>(header->error);
     user_id = header->user_id;
     payload += sizeof(*header);
     if (error == ERROR_NONE) {
         return nonErrorDeserialize(payload, end);
     } else {
         retry_timeout = 0;
         if (error == ERROR_RETRY) {
             if (!fitsBuffer(payload, end, sizeof(retry_timeout))) {
                 return ERROR_INVALID;
             }
             memcpy(&retry_timeout, payload, sizeof(retry_timeout));
         }
     }

     return ERROR_NONE;
 }

 void GateKeeperMessage::SetRetryTimeout(uint32_t retry_timeout) {
     this->retry_timeout = retry_timeout;
     this->error = ERROR_RETRY;
 }

 VerifyRequest::VerifyRequest(uint32_t user_id, uint64_t challenge,
         SizedBuffer enrolled_password_handle, SizedBuffer provided_password_payload) {
     this->user_id = user_id;
     this->challenge = challenge;
     this->password_handle = move(enrolled_password_handle);
     this->provided_password = move(provided_password_payload);
 }

 uint32_t VerifyRequest::nonErrorSerializedSize() const {
     return sizeof(challenge) + serialized_buffer_size(password_handle)
             + serialized_buffer_size(provided_password);
 }

 void VerifyRequest::nonErrorSerialize(uint8_t *buffer) const {
     memcpy(buffer, &challenge, sizeof(challenge));
     buffer += sizeof(challenge);
     append_to_buffer(&buffer, password_handle);
     append_to_buffer(&buffer, provided_password);
 }

 gatekeeper_error_t VerifyRequest::nonErrorDeserialize(const uint8_t *payload, const uint8_t *end) {
     gatekeeper_error_t error = ERROR_NONE;

     password_handle = {};
     provided_password = {};

     if (!fitsBuffer(payload, end, sizeof(challenge))) return ERROR_INVALID;

     memcpy(&challenge, payload, sizeof(challenge));
     payload += sizeof(challenge);

     error = read_from_buffer(&payload, end, &password_handle);
     if (error != ERROR_NONE) return error;

     return read_from_buffer(&payload, end, &provided_password);

 }

 VerifyResponse::VerifyResponse(uint32_t user_id, SizedBuffer auth_token) {
     this->user_id = user_id;
     this->auth_token = move(auth_token);
     this->request_reenroll = false;
 }

 VerifyResponse::VerifyResponse() {
     request_reenroll = false;
 };

 void VerifyResponse::SetVerificationToken(SizedBuffer auth_token) {
     this->auth_token = move(auth_token);
 }

 uint32_t VerifyResponse::nonErrorSerializedSize() const {
     return serialized_buffer_size(auth_token) + sizeof(request_reenroll);
 }

 void VerifyResponse::nonErrorSerialize(uint8_t *buffer) const {
     append_to_buffer(&buffer, auth_token);
     memcpy(buffer, &request_reenroll, sizeof(request_reenroll));
 }

 gatekeeper_error_t VerifyResponse::nonErrorDeserialize(const uint8_t *payload, const uint8_t *end) {

     auth_token = {};

     gatekeeper_error_t err = read_from_buffer(&payload, end, &auth_token);
     if (err != ERROR_NONE) {
         return err;
     }

     if (!fitsBuffer(payload, end, sizeof(request_reenroll))) return ERROR_INVALID;
     memcpy(&request_reenroll, payload, sizeof(request_reenroll));
     return ERROR_NONE;
 }

 EnrollRequest::EnrollRequest(uint32_t user_id, SizedBuffer password_handle,
         SizedBuffer provided_password,  SizedBuffer enrolled_password) {
     this->user_id = user_id;

     this->provided_password = move(provided_password);
     this->enrolled_password = move(enrolled_password);
     this->password_handle = move(password_handle);
 }

 uint32_t EnrollRequest::nonErrorSerializedSize() const {
    return serialized_buffer_size(provided_password) + serialized_buffer_size(enrolled_password)
        + serialized_buffer_size(password_handle);
 }

 void EnrollRequest::nonErrorSerialize(uint8_t *buffer) const {
     append_to_buffer(&buffer, provided_password);
     append_to_buffer(&buffer, enrolled_password);
     append_to_buffer(&buffer, password_handle);
 }

 gatekeeper_error_t EnrollRequest::nonErrorDeserialize(const uint8_t *payload, const uint8_t *end) {
     gatekeeper_error_t ret;

     provided_password = {};
     enrolled_password = {};
     password_handle = {};

      ret = read_from_buffer(&payload, end, &provided_password);
      if (ret != ERROR_NONE) {
          return ret;
      }

      ret = read_from_buffer(&payload, end, &enrolled_password);
      if (ret != ERROR_NONE) {
          return ret;
      }

      return read_from_buffer(&payload, end, &password_handle);
 }

 EnrollResponse::EnrollResponse(uint32_t user_id, SizedBuffer enrolled_password_handle) {
     this->user_id = user_id;
     this->enrolled_password_handle = move(enrolled_password_handle);
 }

 void EnrollResponse::SetEnrolledPasswordHandle(SizedBuffer enrolled_password_handle) {
     this->enrolled_password_handle = move(enrolled_password_handle);
 }

 uint32_t EnrollResponse::nonErrorSerializedSize() const {
     return serialized_buffer_size(enrolled_password_handle);
 }

 void EnrollResponse::nonErrorSerialize(uint8_t *buffer) const {
     append_to_buffer(&buffer, enrolled_password_handle);
 }

 gatekeeper_error_t EnrollResponse::nonErrorDeserialize(const uint8_t *payload, const uint8_t *end) {
     enrolled_password_handle = {};

     return read_from_buffer(&payload, end, &enrolled_password_handle);
 }

 };
	/*
	* Copyright 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 <gatekeeper/gatekeeper_messages.h>

	#include <string.h>

	namespace gatekeeper {

	/**
	* Methods for serializing/deserializing SizedBuffers
	*/

	struct __attribute__((__packed__)) serial_header_t {
	uint32_t error;
	uint32_t user_id;
	};

	static inline bool fitsBuffer(const uint8_t* begin, const uint8_t* end, uint32_t field_size) {
	uintptr_t dummy;
	return !__builtin_add_overflow(reinterpret_cast<uintptr_t>(begin), field_size, &dummy)
	&& dummy <= reinterpret_cast<uintptr_t>(end);
	}

	static inline uint32_t serialized_buffer_size(const SizedBuffer &buf) {
	return sizeof(decltype(buf.size())) + buf.size();
	}

	static inline void append_to_buffer(uint8_t **buffer, const SizedBuffer &to_append) {
	uint32_t length = to_append.size();
	memcpy(*buffer, &length, sizeof(length));
	*buffer += sizeof(length);
	if (length != 0 && to_append.Data<uint8_t>() != nullptr) {
	memcpy(*buffer, to_append.Data<uint8_t>(), length);
	*buffer += length;
	}
	}

	static inline gatekeeper_error_t read_from_buffer(const uint8_t *buffer, const uint8_t end,
	SizedBuffer *target) {
	if (target == nullptr) return ERROR_INVALID;
	if (!fitsBuffer(*buffer, end, sizeof(uint32_t))) return ERROR_INVALID;

	// read length from incomming buffer
	uint32_t length;
	memcpy(&length, *buffer, sizeof(length));
	// advance out buffer
	*buffer += sizeof(length);

	if (length == 0) {
	*target = {};
	} else {
	// sanitize incoming buffer size
	if (!fitsBuffer(*buffer, end, length)) return ERROR_INVALID;

	uint8_t *target_buffer = new(std::nothrow) uint8_t[length];
	if (target_buffer == nullptr) return ERROR_MEMORY_ALLOCATION_FAILED;

	memcpy(target_buffer, *buffer, length);
	*buffer += length;
	*target = { target_buffer, length };
	}
	return ERROR_NONE;
	}


	uint32_t GateKeeperMessage::GetSerializedSize() const {
	if (error == ERROR_NONE) {
	uint32_t size = sizeof(serial_header_t) + nonErrorSerializedSize();
	return size;
	} else {
	uint32_t size = sizeof(serial_header_t);
	if (error == ERROR_RETRY) {
	size += sizeof(retry_timeout);
	}
	return size;
	}
	}

	uint32_t GateKeeperMessage::Serialize(uint8_t buffer, const uint8_t end) const {
	uint32_t bytes_written = 0;
	if (!fitsBuffer(buffer, end, GetSerializedSize())) {
	return 0;
	}

	serial_header_t header = reinterpret_cast<serial_header_t >(buffer);
	if (!fitsBuffer(buffer, end, sizeof(serial_header_t))) return 0;
	header->error = error;
	header->user_id = user_id;
	bytes_written += sizeof(*header);
	buffer += sizeof(*header);
	if (error == ERROR_RETRY) {
	if (!fitsBuffer(buffer, end, sizeof(retry_timeout))) return 0;
	memcpy(buffer, &retry_timeout, sizeof(retry_timeout));
	bytes_written += sizeof(retry_timeout);
	} else if (error == ERROR_NONE) {
	uint32_t serialized_size = nonErrorSerializedSize();
	if (!fitsBuffer(buffer, end, serialized_size)) return 0;
	nonErrorSerialize(buffer);
	bytes_written += serialized_size;
	}
	return bytes_written;
	}

	gatekeeper_error_t GateKeeperMessage::Deserialize(const uint8_t payload, const uint8_t end) {
	if (!fitsBuffer(payload, end, sizeof(serial_header_t))) return ERROR_INVALID;
	const serial_header_t header = reinterpret_cast<const serial_header_t >(payload);
	error = static_cast<gatekeeper_error_t>(header->error);
	user_id = header->user_id;
	payload += sizeof(*header);
	if (error == ERROR_NONE) {
	return nonErrorDeserialize(payload, end);
	} else {
	retry_timeout = 0;
	if (error == ERROR_RETRY) {
	if (!fitsBuffer(payload, end, sizeof(retry_timeout))) {
	return ERROR_INVALID;
	}
	memcpy(&retry_timeout, payload, sizeof(retry_timeout));
	}
	}

	return ERROR_NONE;
	}

	void GateKeeperMessage::SetRetryTimeout(uint32_t retry_timeout) {
	this->retry_timeout = retry_timeout;
	this->error = ERROR_RETRY;
	}

	VerifyRequest::VerifyRequest(uint32_t user_id, uint64_t challenge,
	SizedBuffer enrolled_password_handle, SizedBuffer provided_password_payload) {
	this->user_id = user_id;
	this->challenge = challenge;
	this->password_handle = move(enrolled_password_handle);
	this->provided_password = move(provided_password_payload);
	}

	uint32_t VerifyRequest::nonErrorSerializedSize() const {
	return sizeof(challenge) + serialized_buffer_size(password_handle)
	+ serialized_buffer_size(provided_password);
	}

	void VerifyRequest::nonErrorSerialize(uint8_t *buffer) const {
	memcpy(buffer, &challenge, sizeof(challenge));
	buffer += sizeof(challenge);
	append_to_buffer(&buffer, password_handle);
	append_to_buffer(&buffer, provided_password);
	}

	gatekeeper_error_t VerifyRequest::nonErrorDeserialize(const uint8_t payload, const uint8_t end) {
	gatekeeper_error_t error = ERROR_NONE;

	password_handle = {};
	provided_password = {};

	if (!fitsBuffer(payload, end, sizeof(challenge))) return ERROR_INVALID;

	memcpy(&challenge, payload, sizeof(challenge));
	payload += sizeof(challenge);

	error = read_from_buffer(&payload, end, &password_handle);
	if (error != ERROR_NONE) return error;

	return read_from_buffer(&payload, end, &provided_password);

	}

	VerifyResponse::VerifyResponse(uint32_t user_id, SizedBuffer auth_token) {
	this->user_id = user_id;
	this->auth_token = move(auth_token);
	this->request_reenroll = false;
	}

	VerifyResponse::VerifyResponse() {
	request_reenroll = false;
	};

	void VerifyResponse::SetVerificationToken(SizedBuffer auth_token) {
	this->auth_token = move(auth_token);
	}

	uint32_t VerifyResponse::nonErrorSerializedSize() const {
	return serialized_buffer_size(auth_token) + sizeof(request_reenroll);
	}

	void VerifyResponse::nonErrorSerialize(uint8_t *buffer) const {
	append_to_buffer(&buffer, auth_token);
	memcpy(buffer, &request_reenroll, sizeof(request_reenroll));
	}

	gatekeeper_error_t VerifyResponse::nonErrorDeserialize(const uint8_t payload, const uint8_t end) {

	auth_token = {};

	gatekeeper_error_t err = read_from_buffer(&payload, end, &auth_token);
	if (err != ERROR_NONE) {
	return err;
	}

	if (!fitsBuffer(payload, end, sizeof(request_reenroll))) return ERROR_INVALID;
	memcpy(&request_reenroll, payload, sizeof(request_reenroll));
	return ERROR_NONE;
	}

	EnrollRequest::EnrollRequest(uint32_t user_id, SizedBuffer password_handle,
	SizedBuffer provided_password, SizedBuffer enrolled_password) {
	this->user_id = user_id;

	this->provided_password = move(provided_password);
	this->enrolled_password = move(enrolled_password);
	this->password_handle = move(password_handle);
	}

	uint32_t EnrollRequest::nonErrorSerializedSize() const {
	return serialized_buffer_size(provided_password) + serialized_buffer_size(enrolled_password)
	+ serialized_buffer_size(password_handle);
	}

	void EnrollRequest::nonErrorSerialize(uint8_t *buffer) const {
	append_to_buffer(&buffer, provided_password);
	append_to_buffer(&buffer, enrolled_password);
	append_to_buffer(&buffer, password_handle);
	}

	gatekeeper_error_t EnrollRequest::nonErrorDeserialize(const uint8_t payload, const uint8_t end) {
	gatekeeper_error_t ret;

	provided_password = {};
	enrolled_password = {};
	password_handle = {};

	ret = read_from_buffer(&payload, end, &provided_password);
	if (ret != ERROR_NONE) {
	return ret;
	}

	ret = read_from_buffer(&payload, end, &enrolled_password);
	if (ret != ERROR_NONE) {
	return ret;
	}

	return read_from_buffer(&payload, end, &password_handle);
	}

	EnrollResponse::EnrollResponse(uint32_t user_id, SizedBuffer enrolled_password_handle) {
	this->user_id = user_id;
	this->enrolled_password_handle = move(enrolled_password_handle);
	}

	void EnrollResponse::SetEnrolledPasswordHandle(SizedBuffer enrolled_password_handle) {
	this->enrolled_password_handle = move(enrolled_password_handle);
	}

	uint32_t EnrollResponse::nonErrorSerializedSize() const {
	return serialized_buffer_size(enrolled_password_handle);
	}

	void EnrollResponse::nonErrorSerialize(uint8_t *buffer) const {
	append_to_buffer(&buffer, enrolled_password_handle);
	}

	gatekeeper_error_t EnrollResponse::nonErrorDeserialize(const uint8_t payload, const uint8_t end) {
	enrolled_password_handle = {};

	return read_from_buffer(&payload, end, &enrolled_password_handle);
	}

	};