Implement SoftKeyguard
scrypt/openssl based implementation of Keyguard
Change-Id: Ib04fee3bb34d81bfdb659ab1a9f16efd0cbd630f
diff --git a/keyguard_messages.cpp b/keyguard_messages.cpp
index 2b550c4..d7b90a7 100644
--- a/keyguard_messages.cpp
+++ b/keyguard_messages.cpp
@@ -54,7 +54,7 @@
size_t KeyguardMessage::GetSerializedSize() const {
- if (error_ == KG_ERROR_OK) {
+ if (error == KG_ERROR_OK) {
return 2 * sizeof(uint32_t) + nonErrorSerializedSize();
} else {
return sizeof(uint32_t);
@@ -62,15 +62,15 @@
}
uint8_t *KeyguardMessage::Serialize() const {
- if (error_ != KG_ERROR_OK) {
+ if (error != KG_ERROR_OK) {
uint32_t *error_buf = new uint32_t;
- *error_buf = static_cast<uint32_t>(error_);
+ *error_buf = static_cast<uint32_t>(error);
return reinterpret_cast<uint8_t *>(error_buf);
} else {
uint8_t *buf = new uint8_t[2*sizeof(uint32_t) + nonErrorSerializedSize()];
- uint32_t error_value = static_cast<uint32_t>(error_);
+ uint32_t error_value = static_cast<uint32_t>(error);
memcpy(buf, &error_value, sizeof(uint32_t));
- memcpy(buf + sizeof(uint32_t), &user_id_, sizeof(user_id_));
+ memcpy(buf + sizeof(uint32_t), &user_id, sizeof(user_id));
nonErrorSerialize(buf + 2*sizeof(uint32_t));
return buf;
}
@@ -80,177 +80,177 @@
uint32_t error_value;
if (payload + sizeof(uint32_t) > end) return KG_ERROR_INVALID;
memcpy(&error_value, payload, sizeof(uint32_t));
- error_ = static_cast<keyguard_error_t>(error_value);
+ error = static_cast<keyguard_error_t>(error_value);
payload += sizeof(uint32_t);
- if (error_ == KG_ERROR_OK) {
+ if (error == KG_ERROR_OK) {
if (payload == end) return KG_ERROR_INVALID;
- user_id_ = *((uint32_t *) payload);
- error_ = nonErrorDeserialize(payload + sizeof(uint32_t), end);
+ user_id = *((uint32_t *) payload);
+ error = nonErrorDeserialize(payload + sizeof(uint32_t), end);
}
- return error_;
+ return error;
}
VerifyRequest::VerifyRequest(uint32_t user_id, SizedBuffer *enrolled_password_handle,
SizedBuffer *provided_password_payload) {
- user_id_ = user_id;
- password_handle_.buffer = std::move(enrolled_password_handle->buffer);
- password_handle_.length = enrolled_password_handle->length;
- provided_password_.buffer = std::move(provided_password_payload->buffer);
- provided_password_.length = provided_password_payload->length;
+ this->user_id = user_id;
+ this->password_handle.buffer.reset(enrolled_password_handle->buffer.release());
+ this->password_handle.length = enrolled_password_handle->length;
+ this->provided_password.buffer.reset(provided_password_payload->buffer.release());
+ this->provided_password.length = provided_password_payload->length;
}
VerifyRequest::VerifyRequest() {
- memset_s(&password_handle_, 0, sizeof(password_handle_));
- memset_s(&provided_password_, 0, sizeof(provided_password_));
+ memset_s(&password_handle, 0, sizeof(password_handle));
+ memset_s(&provided_password, 0, sizeof(provided_password));
}
VerifyRequest::~VerifyRequest() {
- if (password_handle_.buffer) {
- password_handle_.buffer.reset();
+ if (password_handle.buffer.get()) {
+ password_handle.buffer.reset();
}
- if (provided_password_.buffer) {
- memset_s(provided_password_.buffer.get(), 0, provided_password_.length);
- provided_password_.buffer.reset();
+ if (provided_password.buffer.get()) {
+ memset_s(provided_password.buffer.get(), 0, provided_password.length);
+ provided_password.buffer.reset();
}
}
size_t VerifyRequest::nonErrorSerializedSize() const {
- return serialized_buffer_size(password_handle_) + serialized_buffer_size(provided_password_);
+ return serialized_buffer_size(password_handle) + serialized_buffer_size(provided_password);
}
void VerifyRequest::nonErrorSerialize(uint8_t *buffer) const {
- append_to_buffer(&buffer, &password_handle_);
- append_to_buffer(&buffer, &provided_password_);
+ append_to_buffer(&buffer, &password_handle);
+ append_to_buffer(&buffer, &provided_password);
}
keyguard_error_t VerifyRequest::nonErrorDeserialize(const uint8_t *payload, const uint8_t *end) {
keyguard_error_t error = KG_ERROR_OK;
- if (password_handle_.buffer) {
- password_handle_.buffer.reset();
+ if (password_handle.buffer.get()) {
+ password_handle.buffer.reset();
}
- if (provided_password_.buffer) {
- memset_s(provided_password_.buffer.get(), 0, provided_password_.length);
- provided_password_.buffer.reset();
+ if (provided_password.buffer.get()) {
+ memset_s(provided_password.buffer.get(), 0, provided_password.length);
+ provided_password.buffer.reset();
}
- error = read_from_buffer(&payload, end, &password_handle_);
+ error = read_from_buffer(&payload, end, &password_handle);
if (error != KG_ERROR_OK) return error;
- return read_from_buffer(&payload, end, &provided_password_);
+ return read_from_buffer(&payload, end, &provided_password);
}
VerifyResponse::VerifyResponse(uint32_t user_id, SizedBuffer *verification_token) {
- user_id_ = user_id;
- verification_token_.buffer = std::move(verification_token->buffer);
- verification_token_.length = verification_token->length;
+ this->user_id = user_id;
+ this->verification_token.buffer.reset(verification_token->buffer.release());
+ this->verification_token.length = verification_token->length;
}
VerifyResponse::VerifyResponse() {
- memset_s(&verification_token_, 0, sizeof(verification_token_));
+ memset_s(&verification_token, 0, sizeof(verification_token));
};
VerifyResponse::~VerifyResponse() {
- if (verification_token_.length > 0) {
- verification_token_.buffer.reset();
+ if (verification_token.length > 0) {
+ verification_token.buffer.reset();
}
}
void VerifyResponse::SetVerificationToken(SizedBuffer *verification_token) {
- verification_token_.buffer = std::move(verification_token->buffer);
- verification_token_.length = verification_token->length;
+ this->verification_token.buffer.reset(verification_token->buffer.release());
+ this->verification_token.length = verification_token->length;
}
size_t VerifyResponse::nonErrorSerializedSize() const {
- return serialized_buffer_size(verification_token_);
+ return serialized_buffer_size(verification_token);
}
void VerifyResponse::nonErrorSerialize(uint8_t *buffer) const {
- append_to_buffer(&buffer, &verification_token_);
+ append_to_buffer(&buffer, &verification_token);
}
keyguard_error_t VerifyResponse::nonErrorDeserialize(const uint8_t *payload, const uint8_t *end) {
- if (verification_token_.buffer) {
- verification_token_.buffer.reset();
+ if (verification_token.buffer.get()) {
+ verification_token.buffer.reset();
}
- return read_from_buffer(&payload, end, &verification_token_);
+ return read_from_buffer(&payload, end, &verification_token);
}
EnrollRequest::EnrollRequest(uint32_t user_id, SizedBuffer *provided_password) {
- user_id_ = user_id;
- provided_password_.buffer = std::move(provided_password->buffer);
- provided_password_.length = provided_password->length;
+ this->user_id = user_id;
+ this->provided_password.buffer.reset(provided_password->buffer.release());
+ this->provided_password.length = provided_password->length;
}
EnrollRequest::EnrollRequest() {
- memset_s(&provided_password_, 0, sizeof(provided_password_));
+ memset_s(&provided_password, 0, sizeof(provided_password));
}
EnrollRequest::~EnrollRequest() {
- if (provided_password_.buffer) {
- memset_s(provided_password_.buffer.get(), 0, provided_password_.length);
- provided_password_.buffer.reset();
+ if (provided_password.buffer.get()) {
+ memset_s(provided_password.buffer.get(), 0, provided_password.length);
+ provided_password.buffer.reset();
}
}
size_t EnrollRequest::nonErrorSerializedSize() const {
- return serialized_buffer_size(provided_password_);
+ return serialized_buffer_size(provided_password);
}
void EnrollRequest::nonErrorSerialize(uint8_t *buffer) const {
- append_to_buffer(&buffer, &provided_password_);
+ append_to_buffer(&buffer, &provided_password);
}
keyguard_error_t EnrollRequest::nonErrorDeserialize(const uint8_t *payload, const uint8_t *end) {
- if (provided_password_.buffer) {
- memset_s(provided_password_.buffer.get(), 0, provided_password_.length);
- provided_password_.buffer.reset();
+ if (provided_password.buffer.get()) {
+ memset_s(provided_password.buffer.get(), 0, provided_password.length);
+ provided_password.buffer.reset();
}
- return read_from_buffer(&payload, end, &provided_password_);
+ return read_from_buffer(&payload, end, &provided_password);
}
EnrollResponse::EnrollResponse(uint32_t user_id, SizedBuffer *enrolled_password_handle) {
- user_id_ = user_id;
- enrolled_password_handle_.buffer = std::move(enrolled_password_handle->buffer);
- enrolled_password_handle_.length = enrolled_password_handle->length;
+ this->user_id = user_id;
+ this->enrolled_password_handle.buffer.reset(enrolled_password_handle->buffer.release());
+ this->enrolled_password_handle.length = enrolled_password_handle->length;
}
EnrollResponse::EnrollResponse() {
- memset_s(&enrolled_password_handle_, 0, sizeof(enrolled_password_handle_));
+ memset_s(&enrolled_password_handle, 0, sizeof(enrolled_password_handle));
}
EnrollResponse::~EnrollResponse() {
- if (enrolled_password_handle_.buffer) {
- enrolled_password_handle_.buffer.reset();
+ if (enrolled_password_handle.buffer.get()) {
+ enrolled_password_handle.buffer.reset();
}
}
void EnrollResponse::SetEnrolledPasswordHandle(SizedBuffer *enrolled_password_handle) {
- enrolled_password_handle_.buffer = std::move(enrolled_password_handle->buffer);
- enrolled_password_handle_.length = enrolled_password_handle->length;
+ this->enrolled_password_handle.buffer.reset(enrolled_password_handle->buffer.release());
+ this->enrolled_password_handle.length = enrolled_password_handle->length;
}
size_t EnrollResponse::nonErrorSerializedSize() const {
- return serialized_buffer_size(enrolled_password_handle_);
+ return serialized_buffer_size(enrolled_password_handle);
}
void EnrollResponse::nonErrorSerialize(uint8_t *buffer) const {
- append_to_buffer(&buffer, &enrolled_password_handle_);
+ append_to_buffer(&buffer, &enrolled_password_handle);
}
keyguard_error_t EnrollResponse::nonErrorDeserialize(const uint8_t *payload, const uint8_t *end) {
- if (enrolled_password_handle_.buffer) {
- enrolled_password_handle_.buffer.reset();
+ if (enrolled_password_handle.buffer.get()) {
+ enrolled_password_handle.buffer.reset();
}
- return read_from_buffer(&payload, end, &enrolled_password_handle_);
+ return read_from_buffer(&payload, end, &enrolled_password_handle);
}
};