Add methods for computing sha256 hashes and validating ed25519 signatures

2 files changed, 161 insertions, 5 deletions

diff --git a/src/olm.cpp b/src/olm.cpp
index cb4291e..28b194f 100644
--- a/src/olm.cpp
+++ b/src/olm.cpp
@@ -15,6 +15,7 @@
 #include "olm/olm.hh"
 #include "olm/session.hh"
 #include "olm/account.hh"
+#include "olm/utility.hh"
 #include "olm/base64.hh"
 #include "olm/cipher.hh"
 #include "olm/memory.hh"
@@ -28,16 +29,24 @@ static OlmAccount * to_c(olm::Account * account) {
     return reinterpret_cast<OlmAccount *>(account);
 }
 
-static OlmSession * to_c(olm::Session * account) {
-    return reinterpret_cast<OlmSession *>(account);
+static OlmSession * to_c(olm::Session * session) {
+    return reinterpret_cast<OlmSession *>(session);
+}
+
+static OlmUtility * to_c(olm::Utility * utility) {
+    return reinterpret_cast<OlmUtility *>(utility);
 }
 
 static olm::Account * from_c(OlmAccount * account) {
     return reinterpret_cast<olm::Account *>(account);
 }
 
-static olm::Session * from_c(OlmSession * account) {
-    return reinterpret_cast<olm::Session *>(account);
+static olm::Session * from_c(OlmSession * session) {
+    return reinterpret_cast<olm::Session *>(session);
+}
+
+static olm::Utility * from_c(OlmUtility * utility) {
+    return reinterpret_cast<olm::Utility *>(utility);
 }
 
 static std::uint8_t * from_c(void * bytes) {
@@ -200,6 +209,16 @@ const char * olm_session_last_error(
     }
 }
 
+const char * olm_utility_last_error(
+    OlmUtility * utility
+) {
+    unsigned error = unsigned(from_c(utility)->last_error);
+    if (error < sizeof(ERRORS)) {
+        return ERRORS[error];
+    } else {
+        return "UNKNOWN_ERROR";
+    }
+}
 
 size_t olm_account_size() {
     return sizeof(olm::Account);
@@ -210,6 +229,9 @@ size_t olm_session_size() {
     return sizeof(olm::Session);
 }
 
+size_t olm_utility_size() {
+    return sizeof(olm::Utility);
+}
 
 OlmAccount * olm_account(
     void * memory
@@ -227,6 +249,14 @@ OlmSession * olm_session(
 }
 
 
+OlmUtility * olm_utility(
+    void * memory
+) {
+    olm::unset(memory, sizeof(olm::Utility));
+    return to_c(new(memory) olm::Utility());
+}
+
+
 size_t olm_clear_account(
     OlmAccount * account
 ) {
@@ -249,6 +279,17 @@ size_t olm_clear_session(
 }
 
 
+size_t olm_clear_utility(
+    OlmUtility * utility
+) {
+    /* Clear the memory backing the session */
+    olm::unset(utility, sizeof(olm::Utility));
+    /* Initialise a fresh session object in case someone tries to use it */
+    new(utility) olm::Utility();
+    return sizeof(olm::Utility);
+}
+
+
 size_t olm_pickle_account_length(
     OlmAccount * account
 ) {
@@ -558,7 +599,6 @@ size_t olm_session_id_length(
     return b64_output_length(from_c(session)->session_id_length());
 }
 
-
 size_t olm_session_id(
     OlmSession * session,
     void * id, size_t id_length
@@ -724,4 +764,63 @@ size_t olm_decrypt(
     );
 }
 
+
+size_t olm_sha256_length(
+   OlmUtility * utility
+) {
+    return b64_output_length(from_c(utility)->sha256_length());
+}
+
+
+size_t olm_sha256(
+    OlmUtility * utility,
+    void const * input, size_t input_length,
+    void * output, size_t output_length
+) {
+    std::size_t raw_length = from_c(utility)->sha256_length();
+    if (output_length < b64_output_length(raw_length)) {
+        from_c(utility)->last_error =
+            olm::ErrorCode::OUTPUT_BUFFER_TOO_SMALL;
+        return std::size_t(-1);
+    }
+    std::size_t result = from_c(utility)->sha256(
+       from_c(input), input_length,
+       b64_output_pos(from_c(output), raw_length), raw_length
+    );
+    if (result == std::size_t(-1)) {
+        return result;
+    }
+    return b64_output(from_c(output), raw_length);
+}
+
+
+size_t olm_ed25519_verify(
+    OlmUtility * utility,
+    void const * key, size_t key_length,
+    void const * message, size_t message_length,
+    void * signature, size_t signature_length
+) {
+    if (olm::decode_base64_length(key_length) != 32) {
+        from_c(utility)->last_error = olm::ErrorCode::INVALID_BASE64;
+        return std::size_t(-1);
+    }
+    olm::Ed25519PublicKey verify_key;
+    olm::decode_base64(
+        from_c(key), key_length,
+        verify_key.public_key
+    );
+    std::size_t raw_signature_length = b64_input(
+        from_c(signature), signature_length, from_c(utility)->last_error
+    );
+    if (raw_signature_length == std::size_t(-1)) {
+        return std::size_t(-1);
+    }
+    return from_c(utility)->ed25519_verify(
+        verify_key,
+        from_c(message), message_length,
+        from_c(signature), raw_signature_length
+    );
+}
+
+
 }
diff --git a/src/utility.cpp b/src/utility.cpp
new file mode 100644
index 0000000..1d8c5c1
--- /dev/null
+++ b/src/utility.cpp
@@ -0,0 +1,57 @@
+/* Copyright 2015 OpenMarket Ltd
+ *
+ * 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 "olm/utility.hh"
+#include "olm/crypto.hh"
+
+
+olm::Utility::Utility(
+) : last_error(olm::ErrorCode::SUCCESS) {
+}
+
+
+size_t olm::Utility::sha256_length() {
+    return olm::HMAC_SHA256_OUTPUT_LENGTH;
+}
+
+
+size_t olm::Utility::sha256(
+    std::uint8_t const * input, std::size_t input_length,
+    std::uint8_t * output, std::size_t output_length
+) {
+    if (output_length < sha256_length()) {
+        last_error = olm::ErrorCode::OUTPUT_BUFFER_TOO_SMALL;
+        return std::size_t(-1);
+    }
+    olm::sha256(input, input_length, output);
+    return 32;
+}
+
+
+size_t olm::Utility::ed25519_verify(
+    Ed25519PublicKey const & key,
+    std::uint8_t const * message, std::size_t message_length,
+    std::uint8_t const * signature, std::size_t signature_length
+) {
+    if (signature_length < 64) {
+        last_error = olm::ErrorCode::BAD_MESSAGE_MAC;
+        return std::size_t(-1);
+    }
+    if (!olm::ed25519_verify(key, message, message_length, signature)) {
+        last_error = olm::ErrorCode::BAD_MESSAGE_MAC;
+        return std::size_t(-1);
+    }
+    return std::size_t(0);
+}