Add SHA1 and SHA256 API's and examples

Author: sandeepmistry

examples/SHA1/SHA1.ino

@@ -0,0 +1,70 @@
+/*
+  ArduinoBearSSL SHA1
+
+  This sketch demonstrates how to create a SHA1 hash and HMAC
+  for an input string.
+
+  This example code is in the public domain.
+*/
+
+#include <ArduinoBearSSL.h>
+
+void setup() {
+  Serial.begin(9600);
+  while (!Serial);
+
+  // expect 0xDA39A3EE5E6B4B0D3255BFEF95601890AFD80709
+  printSHA1("");
+
+  // expect 0x2FD4E1C67A2D28FCED849EE1BB76E7391B93EB12
+  printSHA1("The quick brown fox jumps over the lazy dog");
+
+  // expect 0xFBDB1D1B18AA6C08324B7D64B71FB76370690E1D
+  printHMACSHA1("", "");
+
+  // expect 0xDE7C9B85B8B78AA6BC8A7A36F70A90701C9DB4D9
+  printHMACSHA1("key", "The quick brown fox jumps over the lazy dog");
+}
+
+void loop() {
+}
+
+void printSHA1(const char* str) {
+  Serial.print("SHA1 of '");
+  Serial.print(str);
+  Serial.print("' is 0x");
+
+  SHA1.beginHash();
+  SHA1.print(str);
+  SHA1.endHash();
+
+  printResult();
+}
+
+void printHMACSHA1(const char* secret, const char* str) {
+  Serial.print("HMAC-SHA1 of '");
+  Serial.print(str);
+  Serial.print("' with secret '");
+  Serial.print(secret);
+  Serial.print("' is 0x");
+
+  SHA1.beginHmac(secret);
+  SHA1.print(str);
+  SHA1.endHmac();
+
+  printResult();
+}
+
+void printResult()
+{
+  while (SHA1.available()) {
+    byte b = SHA1.read();
+
+    if (b < 16) {
+      Serial.print("0");
+    }
+
+    Serial.print(b, HEX);
+  }
+  Serial.println();
+}

examples/SHA256/SHA256.ino

@@ -0,0 +1,70 @@
+/*
+  ArduinoBearSSL SHA256
+
+  This sketch demonstrates how to create a SHA256 hash and HMAC
+  for an input string.
+
+  This example code is in the public domain.
+*/
+
+#include <ArduinoBearSSL.h>
+
+void setup() {
+  Serial.begin(9600);
+  while (!Serial);
+
+  // expect 0xE3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855
+  printSHA256("");
+
+  // expect 0xD7A8FBB307D7809469CA9ABCB0082E4F8D5651E46D3CDB762D02D0BF37C9E592
+  printSHA256("The quick brown fox jumps over the lazy dog");
+
+  // expect 0xB613679A0814D9EC772F95D778C35FC5FF1697C493715653C6C712144292C5AD
+  printHMACSHA256("", "");
+
+  // expect 0xF7BC83F430538424B13298E6AA6FB143EF4D59A14946175997479DBC2D1A3CD8
+  printHMACSHA256("key", "The quick brown fox jumps over the lazy dog");
+}
+
+void loop() {
+}
+
+void printSHA256(const char* str) {
+  Serial.print("SHA256 of '");
+  Serial.print(str);
+  Serial.print("' is 0x");
+
+  SHA256.beginHash();
+  SHA256.print(str);
+  SHA256.endHash();
+
+  printResult();
+}
+
+void printHMACSHA256(const char* secret, const char* str) {
+  Serial.print("HMAC-SHA256 of '");
+  Serial.print(str);
+  Serial.print("' with secret '");
+  Serial.print(secret);
+  Serial.print("' is 0x");
+
+  SHA256.beginHmac(secret);
+  SHA256.print(str);
+  SHA256.endHmac();
+
+  printResult();
+}
+
+void printResult()
+{
+  while (SHA256.available()) {
+    byte b = SHA256.read();
+
+    if (b < 16) {
+      Serial.print("0");
+    }
+
+    Serial.print(b, HEX);
+  }
+  Serial.println();
+}

src/ArduinoBearSSL.h

@@ -26,6 +26,8 @@
 #define _ARDUINO_BEAR_SSL_H_
 
 #include "BearSSLClient.h"
+#include "SHA1.h"
+#include "SHA256.h"
 
 class ArduinoBearSSLClass {
 public:

src/SHA.cpp

@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 2019 Arduino SA. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining 
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be 
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "SHA.h"
+
+SHAClass::SHAClass(int blockSize, int digestSize) :
+  _blockSize(blockSize),
+  _digestSize(digestSize),
+  _digestIndex(digestSize)
+{
+  _digest = (uint8_t*)malloc(_digestSize);
+  _secret = (uint8_t*)malloc(_blockSize);
+}
+
+SHAClass::~SHAClass()
+{
+  if (_secret) {
+    free(_secret);
+    _secret = NULL;
+  }
+
+  if (_digest) {
+    free(_digest);
+    _digest = NULL;
+  }
+}
+
+int SHAClass::beginHash()
+{
+  _digestIndex = _digestSize;
+
+  return begin();
+}
+
+int SHAClass::endHash()
+{
+  if (end(_digest) == 0) {
+    _digestIndex = _digestSize;
+    return 0;
+  } else {
+    _digestIndex = 0;
+    return 1;
+  }
+}
+
+int SHAClass::beginHmac(const String& secret)
+{
+  return beginHmac((const uint8_t*)secret.c_str(), secret.length());
+}
+
+int SHAClass::beginHmac(const char* secret)
+{
+  return beginHmac((uint8_t*)secret, strlen(secret));
+}
+
+int SHAClass::beginHmac(const byte secret[], int length)
+{
+  if (length > _blockSize) {
+    if (beginHash() == 0) {
+      return 0;
+    } else if (write(secret, length) != (size_t)length) {
+      return 0;
+    } else if (endHash() == 0) {
+      return 0;
+    }
+    secret = _digest;
+    _secretLength = _digestSize;;
+  } else {
+    _secretLength = length;
+  }
+
+  memset(_secret, 0x00, _blockSize);
+  memcpy(_secret, secret, _secretLength);
+
+  if (beginHash() == 0) {
+    return 0;
+  }
+
+  uint8_t ipad[_blockSize];
+  memcpy(ipad, _secret, _blockSize);
+
+  for (int i = 0; i < _blockSize; i++) {
+    ipad[i] ^= 0x36;
+  }
+
+  return (write(ipad, _blockSize) == (size_t)_blockSize);
+}
+
+int SHAClass::endHmac()
+{
+  if (endHash() == 0) {
+    return 0;
+  }
+
+  uint8_t opad[_blockSize];
+  memcpy(opad, _secret, _blockSize);
+
+  for (int i = 0; i < _blockSize; i++) {
+    opad[i] ^= 0x5c;
+  }
+
+  if (beginHash() == 0) {
+    return 0;
+  }
+
+  if (write(opad, _blockSize) != (size_t)_blockSize) {
+    return 0;
+  }
+
+  if (write(_digest, _digestSize) != (size_t)_digestSize) {
+    return 0;
+  }
+
+  return endHash();
+}
+
+int SHAClass::available()
+{
+  return (_digestSize - _digestIndex);
+}
+
+int SHAClass::read()
+{
+  if (!available()) {
+    return -1;
+  }
+
+  return _digest[_digestIndex++];
+}
+
+size_t SHAClass::readBytes(char *buffer, size_t length)
+{
+  int toCopy = available();
+
+  if (toCopy > (int)length) {
+    toCopy = length;
+  }
+
+  memcpy(buffer, _digest + _digestIndex, toCopy);
+  _digestIndex += toCopy;
+
+  return toCopy;
+}
+
+int SHAClass::peek()
+{
+  if (!available()) {
+    return -1;
+  }
+
+  return _digest[_digestIndex];
+}
+
+void SHAClass::flush()
+{
+  // no-op
+}
+
+size_t SHAClass::write(uint8_t data)
+{
+  return write(&data, sizeof(data));
+}
+
+size_t SHAClass::write(const uint8_t *buffer, size_t size)
+{
+  if (update(buffer, size) == 0) {
+    setWriteError();
+    return 0;
+  }
+
+  return size;
+}