preen

esphome/components/md5/md5.cpp

@@ -49,21 +49,7 @@ void MD5Digest::get_hex(char *output) {
   }
 }
 
-bool MD5Digest::equals_bytes(const uint8_t *expected) {
-  for (size_t i = 0; i < 16; i++) {
-    if (expected[i] != this->digest_[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-bool MD5Digest::equals_hex(const char *expected) {
-  uint8_t parsed[16];
-  if (!parse_hex(expected, parsed, 16))
-    return false;
-  return equals_bytes(parsed);
-}
+bool MD5Digest::equals_bytes(const uint8_t *expected) { return memcmp(this->digest_, expected, 16) == 0; }
 
 }  // namespace md5
 }  // namespace esphome

esphome/components/md5/md5.h

@@ -53,11 +53,8 @@ class MD5Digest : public HashBase {
   /// Get the size of the hex output (32 for MD5)
   size_t get_hex_size() const override { return 32; }
 
-  /// Compare the digest against a provided byte-encoded digest (16 bytes).
-  bool equals_bytes(const uint8_t *expected);
-
-  /// Compare the digest against a provided hex-encoded digest (32 bytes).
-  bool equals_hex(const char *expected);
+  /// Compare the digest against a provided byte-encoded digest (16 bytes)
+  bool equals_bytes(const uint8_t *expected) override;
 
  protected:
   MD5_CTX_TYPE ctx_{};

esphome/components/sha256/sha256.cpp

@@ -19,7 +19,7 @@ void SHA256::init() {
 
 void SHA256::add(const uint8_t *data, size_t len) { mbedtls_sha256_update(&this->ctx_, data, len); }
 
-void SHA256::calculate() { mbedtls_sha256_finish(&this->ctx_, this->hash_); }
+void SHA256::calculate() { mbedtls_sha256_finish(&this->ctx_, this->digest_); }
 
 #elif defined(USE_ESP8266) || defined(USE_RP2040)
 
@@ -34,7 +34,7 @@ void SHA256::add(const uint8_t *data, size_t len) { br_sha256_update(&this->ctx_
 
 void SHA256::calculate() {
   if (!this->calculated_) {
-    br_sha256_out(&this->ctx_, this->hash_);
+    br_sha256_out(&this->ctx_, this->digest_);
     this->calculated_ = true;
   }
 }
@@ -69,7 +69,7 @@ void SHA256::calculate() {
   }
   if (!this->calculated_) {
     unsigned int len = 32;
-    EVP_DigestFinal_ex(this->ctx_, this->hash_, &len);
+    EVP_DigestFinal_ex(this->ctx_, this->digest_, &len);
     this->calculated_ = true;
   }
 }
@@ -78,32 +78,24 @@ void SHA256::calculate() {
 #error "SHA256 not supported on this platform"
 #endif
 
-void SHA256::get_bytes(uint8_t *output) { memcpy(output, this->hash_, 32); }
+void SHA256::get_bytes(uint8_t *output) { memcpy(output, this->digest_, 32); }
 
 void SHA256::get_hex(char *output) {
   for (size_t i = 0; i < 32; i++) {
-    uint8_t byte = this->hash_[i];
+    uint8_t byte = this->digest_[i];
     output[i * 2] = format_hex_char(byte >> 4);
     output[i * 2 + 1] = format_hex_char(byte & 0x0F);
   }
 }
 
+bool SHA256::equals_bytes(const uint8_t *expected) { return memcmp(this->digest_, expected, 32) == 0; }
+
 std::string SHA256::get_hex_string() {
   char buf[65];
   this->get_hex(buf);
   return std::string(buf);
 }
 
-bool SHA256::equals_bytes(const uint8_t *expected) { return memcmp(this->hash_, expected, 32) == 0; }
-
-bool SHA256::equals_hex(const char *expected) {
-  uint8_t parsed[32];
-  if (!parse_hex(expected, parsed, 32)) {
-    return false;
-  }
-  return this->equals_bytes(parsed);
-}
-
 }  // namespace esphome::sha256
 
 #endif  // Platform check

esphome/components/sha256/sha256.h

@@ -40,20 +40,20 @@ class SHA256 : public esphome::HashBase {
   /// Get the size of the hex output (64 for SHA256)
   size_t get_hex_size() const override { return 64; }
 
-  bool equals_bytes(const uint8_t *expected);
-  bool equals_hex(const char *expected);
+  /// Compare the digest against a provided byte-encoded digest (32 bytes)
+  bool equals_bytes(const uint8_t *expected) override;
 
  protected:
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
   mbedtls_sha256_context ctx_{};
-  uint8_t hash_[32];
+  uint8_t digest_[32];
 #elif defined(USE_ESP8266) || defined(USE_RP2040)
   br_sha256_context ctx_{};
-  uint8_t hash_[32];
+  uint8_t digest_[32];
   bool calculated_{false};
 #elif defined(USE_HOST)
   EVP_MD_CTX *ctx_{nullptr};
-  uint8_t hash_[32];
+  uint8_t digest_[32];
   bool calculated_{false};
 #else
 #error "SHA256 not supported on this platform"

esphome/core/hash_base.h

@@ -2,6 +2,8 @@
 
 #include <cstdint>
 #include <cstddef>
+#include <cstring>
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 
@@ -23,6 +25,19 @@ class HashBase {
   /// Retrieve the hash as hex characters
   virtual void get_hex(char *output) = 0;
 
+  /// Compare the hash against a provided byte-encoded hash
+  virtual bool equals_bytes(const uint8_t *expected) = 0;
+
+  /// Compare the hash against a provided hex-encoded hash
+  bool equals_hex(const char *expected) {
+    const size_t hash_bytes = this->get_hex_size() / 2;
+    uint8_t parsed[32];  // Max size for SHA256
+    if (!parse_hex(expected, parsed, hash_bytes)) {
+      return false;
+    }
+    return this->equals_bytes(parsed);
+  }
+
   /// Get the size of the hex output (32 for MD5, 64 for SHA256)
   virtual size_t get_hex_size() const = 0;
 };