Merge pull request #1257 from Links2004/httpUpdate

check bin magic, add peekBytes

cores/esp8266/Esp.cpp

@@ -177,7 +177,36 @@ uint32_t EspClass::getFlashChipSize(void)
     uint8_t * bytes = (uint8_t *) &data;
     // read first 4 byte (magic byte + flash config)
     if(spi_flash_read(0x0000, &data, 4) == SPI_FLASH_RESULT_OK) {
-        switch((bytes[3] & 0xf0) >> 4) {
+        return magicFlashChipSize((bytes[3] & 0xf0) >> 4);
+    }
+    return 0;
+}
+
+uint32_t EspClass::getFlashChipSpeed(void)
+{
+    uint32_t data;
+    uint8_t * bytes = (uint8_t *) &data;
+    // read first 4 byte (magic byte + flash config)
+    if(spi_flash_read(0x0000, &data, 4) == SPI_FLASH_RESULT_OK) {
+        return magicFlashChipSpeed(bytes[3] & 0x0F);
+    }
+    return 0;
+}
+
+FlashMode_t EspClass::getFlashChipMode(void)
+{
+    FlashMode_t mode = FM_UNKNOWN;
+    uint32_t data;
+    uint8_t * bytes = (uint8_t *) &data;
+    // read first 4 byte (magic byte + flash config)
+    if(spi_flash_read(0x0000, &data, 4) == SPI_FLASH_RESULT_OK) {
+        mode = magicFlashChipMode(bytes[2]);
+    }
+    return mode;
+}
+
+uint32_t EspClass::magicFlashChipSize(uint8_t byte) {
+    switch(byte & 0x0F) {
         case 0x0: // 4 Mbit (512KB)
             return (512_kB);
         case 0x1: // 2 MBit (256KB)
@@ -197,17 +226,10 @@ uint32_t EspClass::getFlashChipSize(void)
         default: // fail?
             return 0;
     }
-    }
-    return 0;
 }
 
-uint32_t EspClass::getFlashChipSpeed(void)
+uint32_t EspClass::magicFlashChipSpeed(uint8_t byte) {
-{
+    switch(byte & 0x0F) {
-    uint32_t data;
-    uint8_t * bytes = (uint8_t *) &data;
-    // read first 4 byte (magic byte + flash config)
-    if(spi_flash_read(0x0000, &data, 4) == SPI_FLASH_RESULT_OK) {
-        switch(bytes[3] & 0x0F) {
         case 0x0: // 40 MHz
             return (40_MHz);
         case 0x1: // 26 MHz
@@ -219,22 +241,13 @@ uint32_t EspClass::getFlashChipSpeed(void)
         default: // fail?
             return 0;
     }
-    }
-    return 0;
 }
 
-FlashMode_t EspClass::getFlashChipMode(void)
+FlashMode_t EspClass::magicFlashChipMode(uint8_t byte) {
-{
+    FlashMode_t mode = (FlashMode_t) byte;
-    FlashMode_t mode = FM_UNKNOWN;
-    uint32_t data;
-    uint8_t * bytes = (uint8_t *) &data;
-    // read first 4 byte (magic byte + flash config)
-    if(spi_flash_read(0x0000, &data, 4) == SPI_FLASH_RESULT_OK) {
-        mode = (FlashMode_t) bytes[2];
     if(mode > FM_DOUT) {
         mode = FM_UNKNOWN;
     }
-    }
     return mode;
 }
 

cores/esp8266/Esp.h

@@ -117,6 +117,10 @@ class EspClass {
         FlashMode_t getFlashChipMode();
         uint32_t getFlashChipSizeByChipId();
 
+        uint32_t magicFlashChipSize(uint8_t byte);
+        uint32_t magicFlashChipSpeed(uint8_t byte);
+        FlashMode_t magicFlashChipMode(uint8_t byte);
+
         bool checkFlashConfig(bool needsEquals = false);
 
         bool flashEraseSector(uint32_t sector);

libraries/ESP8266WiFi/src/WiFiClient.cpp

@@ -239,6 +239,27 @@ int WiFiClient::peek()
     return _client->peek();
 }
 
+size_t WiFiClient::peekBytes(uint8_t *buffer, size_t length) {
+    size_t count = 0;
+
+    if(!_client) {
+        return 0;
+    }
+
+    _startMillis = millis();
+    while((available() < (int) length) && ((millis() - _startMillis) < _timeout)) {
+        yield();
+    }
+
+    if(available() < (int) length) {
+        count = available();
+    } else {
+        count = length;
+    }
+
+    return _client->peekBytes((char *)buffer, count);
+}
+
 void WiFiClient::flush()
 {
     if (_client)

libraries/ESP8266WiFi/src/WiFiClient.h

@@ -56,6 +56,10 @@ public:
   virtual int read();
   virtual int read(uint8_t *buf, size_t size);
   virtual int peek();
+  virtual size_t peekBytes(uint8_t *buffer, size_t length);
+  size_t peekBytes(char *buffer, size_t length) {
+    return peekBytes((uint8_t *) buffer, length);
+  }
   virtual void flush();
   virtual void stop();
   virtual uint8_t connected();

libraries/ESP8266WiFi/src/WiFiClientSecure.cpp

@@ -133,6 +133,17 @@ public:
         return _read_ptr[0];
     }
 
+    size_t peekBytes(char *dst, size_t size) {
+        if(!_available) {
+            if(!_readAll())
+                return -1;
+        }
+
+        size_t will_copy = (_available < size) ? _available : size;
+        memcpy(dst, _read_ptr, will_copy);
+        return will_copy;
+    }
+
     int available() {
         auto cb = _available;
         if (cb == 0) {
@@ -278,6 +289,27 @@ int WiFiClientSecure::peek() {
     return _ssl->peek();
 }
 
+size_t WiFiClientSecure::peekBytes(uint8_t *buffer, size_t length) {
+    size_t count = 0;
+
+    if(!_ssl) {
+        return 0;
+    }
+
+    _startMillis = millis();
+    while((available() < (int) length) && ((millis() - _startMillis) < _timeout)) {
+        yield();
+    }
+
+    if(available() < (int) length) {
+        count = available();
+    } else {
+        count = length;
+    }
+
+    return _ssl->peekBytes((char *)buffer, count);
+}
+
 int WiFiClientSecure::available() {
     if (!_ssl)
         return 0;

libraries/ESP8266WiFi/src/WiFiClientSecure.h

@@ -46,6 +46,7 @@ public:
   int available() override;
   int read() override;
   int peek() override;
+  size_t peekBytes(uint8_t *buffer, size_t length) override;
   void stop() override;
 
   void setCertificate(const uint8_t* cert_data, size_t size);

libraries/ESP8266WiFi/src/include/ClientContext.h

@@ -179,6 +179,20 @@ class ClientContext {
             return reinterpret_cast<char*>(_rx_buf->payload)[_rx_buf_offset];
         }
 
+        size_t peekBytes(char *dst, size_t size) {
+            if(!_rx_buf) return 0;
+
+            size_t max_size = _rx_buf->tot_len - _rx_buf_offset;
+            size = (size < max_size) ? size : max_size;
+
+            DEBUGV(":pd %d, %d, %d\r\n", size, _rx_buf->tot_len, _rx_buf_offset);
+            size_t buf_size = _rx_buf->len - _rx_buf_offset;
+            size_t copy_size = (size < buf_size) ? size : buf_size;
+            DEBUGV(":rpi %d, %d\r\n", buf_size, copy_size);
+            os_memcpy(dst, reinterpret_cast<char*>(_rx_buf->payload) + _rx_buf_offset, copy_size);
+            return copy_size;
+        }
+
         void flush() {
             if(!_rx_buf) {
                 return;

libraries/ESP8266httpUpdate/src/ESP8266httpUpdate.cpp

@@ -124,6 +124,12 @@ String ESP8266HTTPUpdate::getLastErrorString(void) {
             return String("Forbidden (403)");
         case HTTP_UE_SERVER_WRONG_HTTP_CODE:
             return String("Wrong HTTP code");
+        case HTTP_UE_SERVER_FAULTY_MD5:
+            return String("Faulty MD5");
+        case HTTP_UE_BIN_VERIFY_HEADER_FAILED:
+            return String("Verify bin header failed");
+        case HTTP_UE_BIN_FOR_WRONG_FLASH:
+            return String("bin for wrong flash size");
     }
 
     return String();
@@ -232,6 +238,33 @@ t_httpUpdate_return ESP8266HTTPUpdate::handleUpdate(HTTPClient * http, const cha
                         DEBUG_HTTP_UPDATE("[httpUpdate] runUpdate flash...\n");
                     }
 
+                    uint8_t buf[4];
+                    if(tcp->peekBytes(&buf[0], 4) != 4) {
+                        DEBUG_HTTP_UPDATE("[httpUpdate] peekBytes magic header failed\n");
+                        lastError = HTTP_UE_BIN_VERIFY_HEADER_FAILED;
+                        http->end();
+                        return HTTP_UPDATE_FAILED;
+                    }
+
+                    // check for valid first magic byte
+                    if(buf[0] != 0xE9) {
+                        DEBUG_HTTP_UPDATE("[httpUpdate] magic header not starts with 0xE9\n");
+                        lastError = HTTP_UE_BIN_VERIFY_HEADER_FAILED;
+                        http->end();
+                        return HTTP_UPDATE_FAILED;
+
+                    }
+
+                    uint32_t bin_flash_size = ESP.magicFlashChipSize((buf[3] & 0xf0) >> 4);
+
+                    // check if new bin fits to SPI flash
+                    if(bin_flash_size > ESP.getFlashChipRealSize()) {
+                        DEBUG_HTTP_UPDATE("[httpUpdate] magic header, new bin not fits SPI Flash\n");
+                        lastError = HTTP_UE_BIN_FOR_WRONG_FLASH;
+                        http->end();
+                        return HTTP_UPDATE_FAILED;
+                    }
+
                     if(runUpdate(*tcp, len, http->header("x-MD5"), command)) {
                         ret = HTTP_UPDATE_OK;
                         DEBUG_HTTP_UPDATE("[httpUpdate] Update ok\n");

libraries/ESP8266httpUpdate/src/ESP8266httpUpdate.h

@@ -45,6 +45,8 @@
 #define HTTP_UE_SERVER_FORBIDDEN            (-103)
 #define HTTP_UE_SERVER_WRONG_HTTP_CODE      (-104)
 #define HTTP_UE_SERVER_FAULTY_MD5           (-105)
+#define HTTP_UE_BIN_VERIFY_HEADER_FAILED    (-106)
+#define HTTP_UE_BIN_FOR_WRONG_FLASH         (-107)
 
 typedef enum {
     HTTP_UPDATE_FAILED,