Add BearSSL client and server, support true bidir, lower memory, modern SSL (#4273)

BearSSL (https://www.bearssl.org) is a TLS(SSL) library written by
Thomas Pornin that is optimized for lower-memory embedded systems
like the ESP8266. It supports a wide variety of modern ciphers and
is unique in that it doesn't perform any memory allocations during
operation (which is the unfortunate bane of the current axTLS).

BearSSL is also absolutely focused on security and by default performs
all its security checks on x.509 certificates during the connection
phase (but if you want to be insecure and dangerous, that's possible
too).

While it does support unidirectional SSL buffers, like axTLS,
as implemented the ESP8266 wrappers only support bidirectional
buffers. These bidirectional buffers avoid deadlocks in protocols
which don't have well separated receive and transmit periods.

This patch adds several classes which allow connecting to TLS servers
using this library in almost the same way as axTLS:
BearSSL::WiFiClientSecure - WiFiClient that supports TLS
BearSSL::WiFiServerSecure - WiFiServer supporting TLS and client certs

It also introduces objects for PEM/DER encoded keys and certificates:
BearSSLX509List - x.509 Certificate (list) for general use
BearSSLPrivateKey - RSA or EC private key
BearSSLPublicKey - RSA or EC public key (i.e. from a public website)

Finally, it adds a Certificate Authority store object which lets
BearSSL access a set of trusted CA certificates on SPIFFS to allow it
to verify the identity of any remote site on the Internet, without
requiring RAM except for the single matching certificate.
CertStoreSPIFFSBearSSL - Certificate store utility

Client certificates are supported for the BearSSL::WiFiClientSecure, and
what's more the BearSSL::WiFiServerSecure can also *require* remote clients
to have a trusted certificate signed by a specific CA (or yourself with
self-signing CAs).

Maximum Fragment Length Negotiation probing and usage are supported, but
be aware that most sites on the Internet don't support it yet.  When
available, you can reduce the memory footprint of the SSL client or server
dramatically (i.e. down to 2-8KB vs. the ~22KB required for a full 16K
receive fragment and 512b send fragment).  You can also manually set a
smaller fragment size and guarantee at your protocol level all data will
fit within it.

Examples are included to show the usage of these new features.

axTLS has been moved to its own namespace, "axtls".  A default "using"
clause allows existing apps to run using axTLS without any changes.

The BearSSL::WiFi{client,server}Secure implements the axTLS
client/server API which lets many end user applications take advantage
of BearSSL with few or no changes.

The BearSSL static library used presently is stored at
https://github.com/earlephilhower/bearssl-esp8266 and can be built
using the standard ESP8266 toolchain.

libraries/ESP8266WebServer/src/ESP8266WebServerSecure.h

@@ -19,43 +19,5 @@
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
-
-#ifndef ESP8266WEBSERVERSECURE_H
-#define ESP8266WEBSERVERSECURE_H
-
-#include <ESP8266WebServer.h>
-#include <WiFiServerSecure.h>
-
-class ESP8266WebServerSecure : public ESP8266WebServer
-{
-public:
-  ESP8266WebServerSecure(IPAddress addr, int port = 443);
-  ESP8266WebServerSecure(int port = 443);
-  virtual ~ESP8266WebServerSecure();
-
-  void setServerKeyAndCert_P(const uint8_t *key, int keyLen, const uint8_t *cert, int certLen);
-  void setServerKeyAndCert(const uint8_t *key, int keyLen, const uint8_t *cert, int certLen);
-
-  WiFiClient client() override { return _currentClientSecure; }
-
-  void begin() override;
-  void handleClient() override;
-  void close() override;
-
-  template<typename T>
-  size_t streamFile(T &file, const String& contentType) {
-    _streamFileCore(file.size(), file.name(), contentType);
-    return _currentClientSecure.write(file);
-  }
-
-private:
-  size_t _currentClientWrite (const char *bytes, size_t len) override { return _currentClientSecure.write((const uint8_t *)bytes, len); }
-  size_t _currentClientWrite_P (PGM_P bytes, size_t len) override { return _currentClientSecure.write_P(bytes, len); }
-
-protected:
-  WiFiServerSecure _serverSecure;
-  WiFiClientSecure _currentClientSecure;
-};
-
-
-#endif //ESP8266WEBSERVERSECURE_H
+#include "ESP8266WebServerSecureAxTLS.h"
+#include "ESP8266WebServerSecureBearSSL.h"

libraries/ESP8266WebServer/src/ESP8266WebServerSecureAxTLS.cpp

@@ -34,6 +34,8 @@
 #define DEBUG_OUTPUT Serial
 #endif
 
+namespace axTLS {
+
 ESP8266WebServerSecure::ESP8266WebServerSecure(IPAddress addr, int port) 
 : _serverSecure(addr, port)
 {
@@ -144,3 +146,4 @@ void ESP8266WebServerSecure::close() {
   _serverSecure.close();
 }
 
+};

libraries/ESP8266WebServer/src/ESP8266WebServerSecureAxTLS.h

@@ -0,0 +1,64 @@
+/*
+  ESP8266WebServerSecure.h - Dead simple HTTPS web-server.
+  Supports only one simultaneous client, knows how to handle GET and POST.
+
+  Copyright (c) 2017 Earle F. Philhower, III. All rights reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+
+#ifndef ESP8266WEBSERVERSECURE_H
+#define ESP8266WEBSERVERSECURE_H
+
+#include <ESP8266WebServer.h>
+#include <WiFiServerSecure.h>
+
+namespace axTLS {
+
+class ESP8266WebServerSecure : public ESP8266WebServer
+{
+public:
+  ESP8266WebServerSecure(IPAddress addr, int port = 443);
+  ESP8266WebServerSecure(int port = 443);
+  virtual ~ESP8266WebServerSecure();
+
+  void setServerKeyAndCert_P(const uint8_t *key, int keyLen, const uint8_t *cert, int certLen);
+  void setServerKeyAndCert(const uint8_t *key, int keyLen, const uint8_t *cert, int certLen);
+
+  WiFiClient client() override { return _currentClientSecure; }
+
+  void begin() override;
+  void handleClient() override;
+  void close() override;
+
+  template<typename T>
+  size_t streamFile(T &file, const String& contentType) {
+    _streamFileCore(file.size(), file.name(), contentType);
+    return _currentClientSecure.write(file);
+  }
+
+private:
+  size_t _currentClientWrite (const char *bytes, size_t len) override { return _currentClientSecure.write((const uint8_t *)bytes, len); }
+  size_t _currentClientWrite_P (PGM_P bytes, size_t len) override { return _currentClientSecure.write_P(bytes, len); }
+
+protected:
+  WiFiServerSecure _serverSecure;
+  WiFiClientSecure _currentClientSecure;
+};
+
+};
+
+#endif //ESP8266WEBSERVERSECURE_H

libraries/ESP8266WebServer/src/ESP8266WebServerSecureBearSSL.cpp

@@ -0,0 +1,165 @@
+/*
+  ESP8266WebServerSecure.cpp - Dead simple HTTPS web-server.
+  Supports only one simultaneous client, knows how to handle GET and POST.
+
+  Copyright (c) 2017 Earle F. Philhower, III. All rights reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+  Modified 8 May 2015 by Hristo Gochkov (proper post and file upload handling)
+*/
+
+
+#include <Arduino.h>
+#include <libb64/cencode.h>
+#include "WiFiServer.h"
+#include "WiFiClient.h"
+#include "ESP8266WebServerSecureBearSSL.h"
+
+//#define DEBUG_ESP_HTTP_SERVER
+#ifdef DEBUG_ESP_PORT
+#define DEBUG_OUTPUT DEBUG_ESP_PORT
+#else
+#define DEBUG_OUTPUT Serial
+#endif
+
+namespace BearSSL {
+
+ESP8266WebServerSecure::ESP8266WebServerSecure(IPAddress addr, int port) 
+: _serverSecure(addr, port)
+{
+}
+
+ESP8266WebServerSecure::ESP8266WebServerSecure(int port)
+: _serverSecure(port)
+{
+}
+
+void ESP8266WebServerSecure::setRSACert(const BearSSLX509List *chain, const BearSSLPrivateKey *sk)
+{
+  _serverSecure.setRSACert(chain, sk);
+}
+
+void ESP8266WebServerSecure::setECCert(const BearSSLX509List *chain, unsigned cert_issuer_key_type, const BearSSLPrivateKey *sk)
+{
+  _serverSecure.setECCert(chain, cert_issuer_key_type, sk);
+}
+
+void ESP8266WebServerSecure::setBufferSizes(int recv, int xmit)
+{
+  _serverSecure.setBufferSizes(recv, xmit);
+}
+
+ESP8266WebServerSecure::~ESP8266WebServerSecure() {
+  // Nothing to do here.
+  // Base class's destructor will be called to clean up itself
+}
+
+// We need to basically cut-n-paste these from WebServer because of the problem
+// of object slicing. The class uses assignment operators like "WiFiClient x=y;"
+// When this happens, even if "y" is a WiFiClientSecure, the main class is 
+// already compiled down into code which will only copy the WiFiClient superclass
+// and not the extra bits for our own class (since when it was compiled it needed
+// to know the size of memory to allocate on the stack for this local variable
+// there's not realy anything else it could do).
+
+void ESP8266WebServerSecure::begin() {
+  _currentStatus = HC_NONE;
+  _serverSecure.begin();
+  if(!_headerKeysCount)
+    collectHeaders(0, 0);
+}
+
+void ESP8266WebServerSecure::handleClient() {
+  if (_currentStatus == HC_NONE) {
+    BearSSL::WiFiClientSecure client = _serverSecure.available();
+    if (!client) {
+      return;
+    }
+
+#ifdef DEBUG_ESP_HTTP_SERVER
+    DEBUG_OUTPUT.println("New secure client");
+#endif
+
+    _currentClientSecure = client;
+    _currentStatus = HC_WAIT_READ;
+    _statusChange = millis();
+  }
+
+  bool keepCurrentClient = false;
+  bool callYield = false;
+
+  if (_currentClientSecure.connected()) {
+    switch (_currentStatus) {
+    case HC_NONE:
+      // No-op to avoid C++ compiler warning
+      break;
+    case HC_WAIT_READ:
+      // Wait for data from client to become available
+      if (_currentClientSecure.available()) {
+        if (_parseRequest(_currentClientSecure)) {
+          _currentClientSecure.setTimeout(HTTP_MAX_SEND_WAIT);
+          _contentLength = CONTENT_LENGTH_NOT_SET;
+          _handleRequest();
+
+          if (_currentClientSecure.connected()) {
+            _currentStatus = HC_WAIT_CLOSE;
+            _statusChange = millis();
+            keepCurrentClient = true;
+          }
+        }
+      } else { // !_currentClient.available()
+        if (millis() - _statusChange <= HTTP_MAX_DATA_WAIT) {
+          keepCurrentClient = true;
+        }
+        callYield = true;
+      }
+      break;
+    case HC_WAIT_CLOSE:
+      // Wait for client to close the connection
+      if (millis() - _statusChange <= HTTP_MAX_CLOSE_WAIT) {
+        keepCurrentClient = true;
+        callYield = true;
+      }
+    }
+  }
+
+  if (!keepCurrentClient) {
+    _currentClientSecure = BearSSL::WiFiClientSecure();
+    _currentStatus = HC_NONE;
+    _currentUpload.reset();
+  }
+
+  if (callYield) {
+    yield();
+  }
+}
+
+void ESP8266WebServerSecure::close() {
+  _currentClientSecure.flush();
+  _currentClientSecure.stop();
+  _serverSecure.close();
+}
+
+
+void ESP8266WebServerSecure::setServerKeyAndCert_P(const uint8_t *key, int keyLen, const uint8_t *cert, int certLen) {
+  _serverSecure.setServerKeyAndCert_P(key, keyLen, cert, certLen);
+}
+
+void ESP8266WebServerSecure::setServerKeyAndCert(const uint8_t *key, int keyLen, const uint8_t *cert, int certLen)
+{
+  _serverSecure.setServerKeyAndCert(key, keyLen, cert, certLen);
+}
+
+};

libraries/ESP8266WebServer/src/ESP8266WebServerSecureBearSSL.h

@@ -0,0 +1,69 @@
+/*
+  ESP8266WebServerSecure.h - Dead simple HTTPS web-server.
+  Supports only one simultaneous client, knows how to handle GET and POST.
+
+  Copyright (c) 2017 Earle F. Philhower, III. All rights reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+
+#ifndef ESP8266WEBSERVERBEARSSL_H
+#define ESP8266WEBSERVERBEARSSL_H
+
+#include <ESP8266WebServer.h>
+#include <BearSSLHelpers.h>
+#include <WiFiServerSecureBearSSL.h>
+
+namespace BearSSL {
+
+class ESP8266WebServerSecure : public ESP8266WebServer
+{
+public:
+  ESP8266WebServerSecure(IPAddress addr, int port = 443);
+  ESP8266WebServerSecure(int port = 443);
+  virtual ~ESP8266WebServerSecure();
+
+  void setBufferSizes(int recv, int xmit);
+  void setRSACert(const BearSSLX509List *chain, const BearSSLPrivateKey *sk);
+  void setECCert(const BearSSLX509List *chain, unsigned cert_issuer_key_type, const BearSSLPrivateKey *sk);
+
+  WiFiClient client() override { return _currentClientSecure; }
+
+  void begin() override;
+  void handleClient() override;
+  void close() override;
+
+  template<typename T>
+  size_t streamFile(T &file, const String& contentType) {
+    _streamFileCore(file.size(), file.name(), contentType);
+    return _currentClientSecure.write(file);
+  }
+
+  // AXTLS Compatibility
+  void setServerKeyAndCert_P(const uint8_t *key, int keyLen, const uint8_t *cert, int certLen);
+  void setServerKeyAndCert(const uint8_t *key, int keyLen, const uint8_t *cert, int certLen);
+
+private:
+  size_t _currentClientWrite (const char *bytes, size_t len) override { return _currentClientSecure.write((const uint8_t *)bytes, len); }
+  size_t _currentClientWrite_P (PGM_P bytes, size_t len) override { return _currentClientSecure.write_P(bytes, len); }
+
+protected:
+  BearSSL::WiFiServerSecure _serverSecure;
+  BearSSL::WiFiClientSecure _currentClientSecure;
+};
+
+};
+#endif //ESP8266WEBSERVERSECURE_H