diff --git a/doc/esp8266wifi/client-class.rst b/doc/esp8266wifi/client-class.rst
index 2f153b254d..dee85589a1 100644
--- a/doc/esp8266wifi/client-class.rst
+++ b/doc/esp8266wifi/client-class.rst
@@ -107,7 +107,4 @@ Other Function Calls
     IPAddress  localIP () 
     uint16_t  localPort () 
 
-Documentation for the above functions is not yet prepared.
-
-For code samples please refer to separate section with `examples
-:arrow\_right: <client-examples.rst>`__ dedicated specifically to the Client Class.
+Documentation for the above functions is not yet available.
diff --git a/doc/esp8266wifi/client-examples.rst b/doc/esp8266wifi/client-examples.rst
deleted file mode 100644
index b5bb605862..0000000000
--- a/doc/esp8266wifi/client-examples.rst
+++ /dev/null
@@ -1,322 +0,0 @@
-:orphan:
-
-Client
-------
-
-Let's write a simple client program to access a single web page and display its contents on a serial monitor. This is typical operation performed by a client to access server's API to retrieve specific information. For instance we may want to contact GitHub's API to periodically check the number of open issues reported on `esp8266/Arduino <https://github.com/esp8266/Arduino/issues>`__ repository.
-
-Table of Contents
------------------
-
--  `Introduction <#introduction>`__
--  `Get Connected to Wi-Fi <#get-connected-to-wi-fi>`__
--  `Select a Server <#select-a-server>`__
--  `Instantiate the Client <#instantiate-the-client>`__
--  `Get Connected to the Server <#get-connected-to-the-server>`__
--  `Request the Data <#request-the-data>`__
--  `Read Reply from the Server <#read-reply-from-the-server>`__
--  `Now to the Sketch <#now-to-the-sketch>`__
--  `Test it Live <#test-it-live>`__
--  `Test it More <#test-it-more>`__
--  `Conclusion <#conclusion>`__
-
-Introduction
-~~~~~~~~~~~~
-
-This time we are going to concentrate just on retrieving a web page contents sent by a server, to demonstrate basic client's functionality. Once you are able to retrieve information from a server, you should be able to phrase it and extract specific data you need.
-
-Get Connected to Wi-Fi
-~~~~~~~~~~~~~~~~~~~~~~
-
-We should start with connecting the module to an access point to obtain an access to internet. The code to provide this functionality has been already discussed in chapter `Quick Start <readme.rst#quick-start>`__. Please refer to it for details.
-
-Select a Server
-~~~~~~~~~~~~~~~
-
-Once connected to the network we should connect to the specific server. Web address of this server is declared in ``host`` character string as below.
-
-.. code:: cpp
-
-    const char* host = "www.example.com";
-
-I have selected ``www.example.com`` domain name and you can select any other. Just check if you can access it using a web browser.
-
-.. figure:: pictures/client-example-domain.png
-   :alt: A web page to be retreived by the clinet program
-
-   alt text
-
-Instantiate the Client
-~~~~~~~~~~~~~~~~~~~~~~
-
-Now we should declare a client that will be contacting the host (server):
-
-.. code:: cpp
-
-    WiFiClient client;
-
-Get Connected to the Server
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-In next line we will connect to the host and check the connection result. Note ``80``, that is the standard port number used for web access.
-
-.. code:: cpp
-
-    if (client.connect(host, 80))
-    {
-      // we are connected to the host!
-    }
-    else
-    {
-      // connection failure
-    }
-
-Request the Data
-~~~~~~~~~~~~~~~~
-
-If connection is successful, we should send request the host to provide specific information we need. This is done using the `HTTP GET <https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods>`__ request as in the following lines:
-
-.. code:: cpp
-
-    client.print(String("GET /") + " HTTP/1.1\r\n" +
-                 "Host: " + host + "\r\n" +
-                 "Connection: close\r\n" +
-                 "\r\n"
-                );
-
-Read Reply from the Server
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Then, while connection by our client is still alive or while data are available to read (``while (client.connected() || client.available())``, see below) we can read line by line and print out server's response:
-
-.. code:: cpp
-
-    while (client.connected() || client.available())
-    {
-      if (client.available())
-      {
-        String line = client.readStringUntil('\n');
-        Serial.println(line);
-      }
-    }
-
-The inner ``if (client.available())`` is checking if there are any data available from the server. If so, then they are printed out.
-
-Data can be unavailable while the TCP connection is still alive. That means data could be later received.
-
-Once server sends all requested data it will disconnect, then once all received data are read, program will exit the ``while`` loop.
-
-Now to the Sketch
-~~~~~~~~~~~~~~~~~
-
-Complete sketch, including a case when contention to the server fails, is presented below.
-
-.. code:: cpp
-
-    #include <ESP8266WiFi.h>
-
-    const char* ssid = "********";
-    const char* password = "********";
-
-    const char* host = "www.example.com";
-
-
-    void setup()
-    {
-      Serial.begin(115200);
-      Serial.println();
-
-      Serial.printf("Connecting to %s ", ssid);
-      WiFi.begin(ssid, password);
-      while (WiFi.status() != WL_CONNECTED)
-      {
-        delay(500);
-        Serial.print(".");
-      }
-      Serial.println(" connected");
-    }
-
-
-    void loop()
-    {
-      WiFiClient client;
-
-      Serial.printf("\n[Connecting to %s ... ", host);
-      if (client.connect(host, 80))
-      {
-        Serial.println("connected]");
-
-        Serial.println("[Sending a request]");
-        client.print(String("GET /") + " HTTP/1.1\r\n" +
-                     "Host: " + host + "\r\n" +
-                     "Connection: close\r\n" +
-                     "\r\n"
-                    );
-
-        Serial.println("[Response:]");
-        while (client.connected() || client.available())
-        {
-          if (client.available())
-          {
-            String line = client.readStringUntil('\n');
-            Serial.println(line);
-          }
-        }
-        client.stop();
-        Serial.println("\n[Disconnected]");
-      }
-      else
-      {
-        Serial.println("connection failed!]");
-        client.stop();
-      }
-      delay(5000);
-    }
-
-Test it Live
-~~~~~~~~~~~~
-
-Upload sketch the module and open serial monitor. You should see a log similar to presented below.
-
-First, after establishing Wi-Fi connection, you should see confirmation, that client connected to the server and send the request:
-
-::
-
-    Connecting to sensor-net ........ connected
-
-    [Connecting to www.example.com ... connected]
-    [Sending a request]
-
-Then, after getting the request, server will first respond with a header that specifies what type of information will follow (e.g. ``Content-Type: text/html``), how long it is (like ``Content-Length: 1270``), etc.:
-
-::
-
-    [Response:]
-    HTTP/1.1 200 OK
-
-    Cache-Control: max-age=604800
-    Content-Type: text/html
-    Date: Sat, 30 Jul 2016 12:30:45 GMT
-    Etag: "359670651+ident"
-    Expires: Sat, 06 Aug 2016 12:30:45 GMT
-    Last-Modified: Fri, 09 Aug 2013 23:54:35 GMT
-    Server: ECS (ewr/15BD)
-    Vary: Accept-Encoding
-    X-Cache: HIT
-    x-ec-custom-error: 1
-    Content-Length: 1270
-    Connection: close
-
-End of header is marked with an empty line and then you should see the HTML code of requested web page.
-
-::
-
-    <!doctype html>
-    <html>
-    <head>
-        <title>Example Domain</title>
-
-        <meta charset="utf-8" />
-        <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
-        <meta name="viewport" content="width=device-width, initial-scale=1" />
-        <style type="text/css">
-
-    (...)
-
-    </head>
-
-    <body>
-    <div>
-        <h1>Example Domain</h1>
-        <p>This domain is established to be used for illustrative examples in documents. You may use this
-        domain in examples without prior coordination or asking for permission.</p>
-        <p><a href="https://www.iana.org/domains/example">More information...</a></p>
-    </div>
-    </body>
-    </html>
-
-    [Disconnected]
-
-Test it More
-~~~~~~~~~~~~
-
-In case server's web address is incorrect, or server is not accessible, you should see the following short and simple message on the serial monitor:
-
-::
-
-    Connecting to sensor-net ........ connected
-
-    [Connecting to www.wrong-example.com ... connection failed!]
-
-
-General client loop
-~~~~~~~~~~~~~~~~~~~
-
-Here is a general TCP sending / receiving loop:
-
-.. code:: cpp
-
-    while (client.available() || client.connected())
-    {
-        if (client.available())
-        {
-            // client.available() bytes are immediately available for reading
-            // warning: reading them *allows* peer to send more, so they should
-            // be read *only* when they can immediately be processed, see below
-            // for flow control
-        }
-        if (client.connected())
-        {
-            if (client.availableForWrite() >= N)
-            {
-                // TCP layer will be able to *bufferize* our N bytes,
-                // and send them *asynchronously*, with by default
-                // a small delay if those data are small
-                // because Nagle is around (~200ms)
-                // unless client.setNoDelay(true) was called.
-                //
-                // In any case client.write() will *never* block here
-            }
-            else
-            {
-                // or we can send but it will take time because data are too
-                // big to be asynchronously bufferized: TCP needs to receive
-                // some ACKs to release its buffers.
-                // That means that write() will block until it receives
-                // authorization to send because we are not in a
-                // multitasking environment
-
-                // It is always OK to do this, client.availableForWrite() is
-                // only needed when efficiency is a priority and when data
-                // to send can wait where they currently are, especially
-                // when they are in another tcp client.
-
-                // Flow control:
-                // It is also important to know that the ACKs we are sending
-                // to remote are directly generated from client.read().
-                // It means that:
-                // Not immediately reading available data can be good for
-                // flow control and avoid useless memory filling/overflow by
-                // preventing peer from sending more data, and slow down
-                // incoming bandwidth
-                // (tcp is really a nice and efficient beast)
-            }
-        }
-
-        // this is necessary for long duration loops (harmless otherwise)
-
-        yield();
-    }
-
-Conclusion
-~~~~~~~~~~
-
-With this simple example we have demonstrated how to set up a client program, connect it to a server, request a web page and retrieve it. Now you should be able to write your own client program for ESP8266 and move to more advanced dialogue with a server, like e.g. using `HTTPS <https://en.wikipedia.org/wiki/HTTPS>`__ protocol with the `Client Secure <client-secure-examples.rst>`__ .
-
-For more client examples please check
-
-- `WiFiClientBasic.ino <https://github.com/esp8266/Arduino/blob/master/libraries/ESP8266WiFi/examples/WiFiClientBasic/WiFiClientBasic.ino>`__ - a simple sketch that sends a message to a TCP server
-
-- `WiFiClient.ino <https://github.com/esp8266/Arduino/blob/master/libraries/ESP8266WiFi/examples/WiFiClient/WiFiClient.ino>`__ - this sketch sends data via HTTP GET requests to data.sparkfun.com service.
-
-For the list of functions provided to manage clients, please refer to the `Client Class :arrow\_right: <client-class.rst>`__ documentation.
diff --git a/doc/esp8266wifi/client-secure-class.rst b/doc/esp8266wifi/client-secure-class.rst
deleted file mode 100644
index 597a198cc7..0000000000
--- a/doc/esp8266wifi/client-secure-class.rst
+++ /dev/null
@@ -1,102 +0,0 @@
-:orphan:
-
-Client Secure Class
--------------------
-
-Methods and properties described in this section are specific to ESP8266. They are not covered in `Arduino WiFi library <https://www.arduino.cc/en/Reference/WiFi>`__ documentation. Before they are fully documented please refer to information below.
-
-Supported crypto
-~~~~~~~~~~~~~~~~
-
-In the background the library `axtls <http://axtls.sourceforge.net>`_ is used. The library supports only rsa certificates and no new eliptic curve certificates. TLSv1.2 is supported since SDK 2.4.0-rc1.
-
-The following ciphers and digests are supported by `specification <http://axtls.sourceforge.net/specifications.htm>`_:
-
-* Symmetric Ciphers
-    * AES128-SHA
-    * AES256-SHA
-    * AES128-SHA256
-    * AES256-SHA256
-* Asymmetric Ciphers
-    * RSA 512/1024/2048/4096 bit encryption/decryption.
-    * RSA signing/verification
-* Digests
-    * SHA1
-    * MD5
-    * SHA256/384/512
-    * HMAC-SHA1
-    * HMAC-MD5
-    * HMAC-SHA256
-
-loadCertificate
-~~~~~~~~~~~~~~~
-
-Load client certificate from file system.
-
-.. code:: cpp
-
-    loadCertificate(file) 
-
-*Declarations*
-
-.. code:: cpp
-
-    #include <FS.h>
-    #include <LittleFS.h>
-    #include <ESP8266WiFi.h>
-    #include <WiFiClientSecure.h>
-
-    const char* certificateFile = "/client.cer";
-
-*setup() or loop()*
-
-.. code:: cpp
-
-    if (!LittleFS.begin())
-    {
-      Serial.println("Failed to mount the file system");
-      return;
-    }
-
-    Serial.printf("Opening %s", certificateFile);
-    File crtFile = LittleFS.open(certificateFile, "r");
-    if (!crtFile)
-    {
-      Serial.println(" Failed!");
-    }
-
-    WiFiClientSecure client;
-
-    Serial.print("Loading %s", certificateFile);
-    if (!client.loadCertificate(crtFile))
-    {
-      Serial.println(" Failed!");
-    }
-
-    // proceed with connecting of client to the host
-
-setCertificate
-~~~~~~~~~~~~~~
-
-Load client certificate from C array.
-
-.. code:: cpp
-
-    setCertificate (array, size) 
-
-For a practical example please check `this interesting blog <https://nofurtherquestions.wordpress.com/2016/03/14/making-an-esp8266-web-accessible/>`__.
-
-Other Function Calls
-~~~~~~~~~~~~~~~~~~~~
-
-.. code:: cpp
-
-    bool  verify (const char *fingerprint, const char *domain_name) 
-    void  setPrivateKey (const uint8_t *pk, size_t size) 
-    bool  loadCertificate (Stream &stream, size_t size) 
-    bool  loadPrivateKey (Stream &stream, size_t size) 
-    template<typename TFile >  bool  loadPrivateKey (TFile &file)
-
-Documentation for the above functions is not yet prepared.
-
-For code samples please refer to separate section with `examples <client-secure-examples.rst>`__ dedicated specifically to the Client Secure Class.
diff --git a/doc/esp8266wifi/client-secure-examples.rst b/doc/esp8266wifi/client-secure-examples.rst
deleted file mode 100644
index aa74b40b9c..0000000000
--- a/doc/esp8266wifi/client-secure-examples.rst
+++ /dev/null
@@ -1,181 +0,0 @@
-:orphan:
-
-Client Secure
--------------
-
-The client secure is a `client <#client>`__ but secure. Application example below will be easier to follow if you check similar and simpler `example <client-examples.rst>`__ for the "ordinary" client. That being said we will concentrate on discussing the code that is specific to the client secure.
-
-Table of Contents
------------------
-
--  `Introduction <#introduction>`__
--  `The Sketch <#the-sketch>`__
--  `How to Verify Server's
-   Identity? <#how-to-verify-server-s-identity>`__
--  `Get the Fingerprint <#get-the-fingerprint>`__
--  `Connect to the Server <#connect-to-the-server>`__
--  `Is it THAT Server? <#is-it-that-server>`__
--  `GET Response from the Server <#get-response-from-the-server>`__
--  `Read and Check the Response <#read-and-check-the-response>`__
--  `Does it Work? <#does-it-work>`__
--  `Conclusion <#conclusion>`__
-
-Introduction
-~~~~~~~~~~~~
-
-In this example we will be retrieving information from a secure server https://api.github.com. This server is set up in place to provide specific and structured information on `GitHub <https://github.com>`__ repositories. For instance, we may ask it to provide us the build status or the latest version of `esp8266 /
-Adruino <https://github.com/esp8266/Arduino/>`__ core.
-
-The build status of esp8266 / Adruino may be checked on the repository's `home page <https://github.com/esp8266/Arduino#using-git-version>`__ or on `Travis CI <https://travis-ci.org/esp8266/Arduino>`__ site as below:
-
-.. figure:: pictures/esp8266-arduino-build-status-travisci.png
-   :alt: Build status of esp8266 / Arduino repository on Travis CI site
-
-   alt text
-
-GitHub provides a separate server with `API <https://developer.github.com/v3/>`__ to access such information is structured form as `JSON <https://en.wikipedia.org/wiki/JSON>`__.
-
-As you may guess we will use the client secure to contact https://api.github.com server and request the `build status <https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref>`__. If we open specific resource provided in the API with a web browser, the following should show up:
-
-.. figure:: pictures/esp8266-arduino-build-status-json.png
-   :alt: Build status of esp8266 / Arduino repository in JSON fromat
-
-   alt text
-
-What we need to do, is to use client secure to connect to ``https://api.github.com``, to GET ``/repos/esp8266/Arduino/commits/master/status``, search for the line ``"state": "success"`` and display "Build Successful" if we find it, or "Build Failed" if otherwise.
-
-The Sketch
-~~~~~~~~~~
-
-A classic `sketch <https://github.com/esp8266/Arduino/blob/master/libraries/ESP8266WiFi/examples/HTTPSRequest/HTTPSRequest.ino>`__ that is doing what we need is already available among `examples <https://github.com/esp8266/Arduino/tree/master/libraries/ESP8266WiFi/examples>`__ of ESP8266WiFi library. Please open it to go through it step by step.
-
-How to Verify Server's Identity?
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-To establish a secure connection with a server we need to verify server's identity. Clients that run on "regular" computers do it by comparing server's certificate with locally stored list of trusted root certificates. Such certificates take several hundreds of KB, so it is not a good option for an ESP module. As an alternative we can use much smaller SHA1 fingerprint of specific certificate.
-
-In declaration section of code we provide the name of ``host`` and the corresponding ``fingerprint``.
-
-.. code:: cpp
-
-    const char* host = "api.github.com";
-    const char* fingerprint = "CF 05 98 89 CA FF 8E D8 5E 5C E0 C2 E4 F7 E6 C3 C7 50 DD 5C";
-
-Get the Fingerprint
-~~~~~~~~~~~~~~~~~~~
-
-We can obtain the ``fingerprint`` for specific ``host`` using a web browser. For instance on Chrome press *Ctrl+Shift+I* and go to *Security > View Certificate > Details > Thumbprint*. This will show a window like below where you can copy the fingerprint and paste it into sketch.
-
-.. figure:: pictures/client-secure-check-fingerprint.png
-   :alt: Locating the fingerprint of GitHub api
-
-   alt text
-
-Remaining steps look almost identical as for the `non-secure client example <client-examples.rst>`__.
-
-Connect to the Server
-~~~~~~~~~~~~~~~~~~~~~
-
-Instantiate the ``WiFiClientSecure`` object and establish a connection (please note we need to use specific ``httpsPort`` for secure connections):
-
-.. code:: cpp
-
-    WiFiClientSecure client;
-    Serial.print("connecting to ");
-    Serial.println(host);
-    if (!client.connect(host, httpsPort)) {
-      Serial.println("connection failed");
-      return;
-    }
-
-Is it THAT Server?
-~~~~~~~~~~~~~~~~~~
-
-Now verify if the fingerprint we have matches this one provided by the server:
-
-.. code:: cpp
-
-    if (client.verify(fingerprint, host)) {
-      Serial.println("certificate matches");
-    } else {
-      Serial.println("certificate doesn't match");
-    }
-
-If this check fails, it is up to you to decide if to proceed further or abort connection. Also note that certificates have specific validity period. Therefore the fingerprint of certificate we have checked today, will certainly be invalid some time later.
-
-GET Response from the Server
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-In the next steps we should execute GET command. This is done is similar way as discussed in `non-secure client example <client-examples.rst>`__.
-
-.. code:: cpp
-
-    client.print(String("GET ") + url + " HTTP/1.1\r\n" +
-                 "Host: " + host + "\r\n" +
-                 "User-Agent: BuildFailureDetectorESP8266\r\n" +
-                 "Connection: close\r\n\r\n");
-
-After sending the request we should wait for a reply and then process received information.
-
-Out of received reply we can skip response header. This can be done by reading until an empty line ``"\r"`` that marks the end of the header:
-
-.. code:: cpp
-
-    while (client.connected()) {
-      String line = client.readStringUntil('\n');
-      if (line == "\r") {
-        Serial.println("headers received");
-        break;
-      }
-    }
-
-Read and Check the Response
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Finally we should read JSON provided by server and check if it contains ``{"state": "success"``:
-
-.. code:: cpp
-
-    String line = client.readStringUntil('\n');
-    if (line.startsWith("{\"state\":\"success\"")) {
-      Serial.println("esp8266/Arduino CI successfull!");
-    } else {
-      Serial.println("esp8266/Arduino CI has failed");
-    }
-
-Does it Work?
-~~~~~~~~~~~~~
-
-Now once you know how it should work, get the `sketch <https://github.com/esp8266/Arduino/blob/master/libraries/ESP8266WiFi/examples/HTTPSRequest/HTTPSRequest.ino>`__. Update credentials to your Wi-Fi network. Check the current fingerprint of ``api.github.com`` and update it if required. Then upload sketch and open a serial monitor.
-
-If everything is fine (including build status of esp8266 / Arduino) you should see message as below:
-
-::
-
-    connecting to sensor-net
-    ........
-    WiFi connected
-    IP address: 
-    192.168.1.104
-    connecting to api.github.com
-    certificate matches
-    requesting URL: /repos/esp8266/Arduino/commits/master/status
-    request sent
-    headers received
-    esp8266/Arduino CI successfull!
-    reply was:
-    ==========
-    {"state":"success","statuses":[{"url":"https://api.github.com/repos/esp8266/Arduino/statuses/8cd331a8bae04a6f1443ff0c93539af4720d8ddf","id":677326372,"state":"success","description":"The Travis CI build passed","target_url":"https://travis-ci.org/esp8266/Arduino/builds/148827821","context":"continuous-integration/travis-ci/push","created_at":"2016-08-01T09:54:38Z","updated_at":"2016-08-01T09:54:38Z"},{"url":"https://api.github.com/repos/esp8266/Arduino/statuses/8cd331a8bae04a6f1443ff0c93539af4720d8ddf","id":677333081,"state":"success","description":"27.62% (+0.00%) compared to 0718188","target_url":"https://codecov.io/gh/esp8266/Arduino/commit/8cd331a8bae04a6f1443ff0c93539af4720d8ddf","context":"codecov/project","created_at":"2016-08-01T09:59:05Z","updated_at":"2016-08-01T09:59:05Z"},
-
-    (...)
-
-    ==========
-    closing connection
-
-Conclusion
-~~~~~~~~~~
-
-Programming a secure client is almost identical as programming a non-secure client. The difference gets down to one extra step to verify server's identity. Keep in mind limitations due to heavy memory usage that depends on the strength of the key used by the server and whether server is willing to negotiate the `TLS buffer size <https://www.igvita.com/2013/10/24/optimizing-tls-record-size-and-buffering-latency/>`__.
-
-For the list of functions provided to manage secure clients, please refer to the `Client Secure Class
-:arrow\_right: <client-secure-class.rst>`__ documentation.
diff --git a/doc/esp8266wifi/readme.rst b/doc/esp8266wifi/readme.rst
index 802b3f954b..7040acb538 100644
--- a/doc/esp8266wifi/readme.rst
+++ b/doc/esp8266wifi/readme.rst
@@ -154,18 +154,7 @@ The Client class creates `clients <https://en.wikipedia.org/wiki/Client_(computi
 .. figure:: pictures/esp8266-client.png
    :alt: ESP8266 operating as the Client
 
-Check out the separate section with `examples <client-examples.rst>`__ / `list of functions <client-class.rst>`__
-
-axTLS Client Secure - DEPRECATED
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The following section details axTLS, the older TLS library used by the project.  It is still supported, but additional fixes and documentation will generally not be undertaken.  See the following section for the updated TLS client object.
-
-The axTLS Client Secure is an extension of `Client Class <#client>`__ where connection and data exchange with servers is done using a `secure protocol <https://en.wikipedia.org/wiki/Transport_Layer_Security>`__. It supports `TLS 1.1 <https://en.wikipedia.org/wiki/Transport_Layer_Security#TLS_1.1>`__. The `TLS 1.2 <https://en.wikipedia.org/wiki/Transport_Layer_Security#TLS_1.2>`__ is not supported.
-
-Secure applications have additional memory (and processing) overhead due to the need to run cryptography algorithms. The stronger the certificate's key, the more overhead is needed. In practice it is not possible to run more than a single secure client at a time. The problem concerns RAM memory we can not add; the flash memory size is usually not the issue. If you would like to learn how `client secure library <https://github.com/esp8266/Arduino/blob/master/libraries/ESP8266WiFi/src/WiFiClientSecure.h>`__ has been developed, what server access has been tested, and how memory limitations have been overcome, read this fascinating issue report `#43 <https://github.com/esp8266/Arduino/issues/43>`__.
-
-Check out the separate section with `examples <client-secure-examples.rst>`__ / `list of functions <client-secure-class.rst>`__
+Check out the separate section with `list of functions <client-class.rst>`__
 
 
 BearSSL Client Secure and Server Secure
@@ -182,6 +171,9 @@ Secure clients and servers require siginificant amounts of additional memory and
 
 `BearSSL::WiFiServerSecure <bearssl-server-secure-class.rst>`__ discusses the TLS server mode available.  Please read and understand the `BearSSL::WiFiClientSecure <bearssl-client-secure-class.rst>`__ first as the server uses most of the same concepts.
 
+Check out the separate section with `examples <client-secure-examples.rst>`__ .
+
+
 Server
 ~~~~~~
 
diff --git a/doc/esp8266wifi/server-examples.rst b/doc/esp8266wifi/server-examples.rst
index 8fe5f71acf..cf5ad51b84 100644
--- a/doc/esp8266wifi/server-examples.rst
+++ b/doc/esp8266wifi/server-examples.rst
@@ -238,11 +238,6 @@ The page would be refreshed every 5 seconds. Each time this happens, you should
     Connection: Keep-Alive
     [client disonnected]
 
-What Else?
-~~~~~~~~~~
-
-Looking on `client examples <client-examples.rst>`__ you will quickly find out the similarities in protocol to the server. The protocol starts with a header that contains information what communication will be about. It contains what content type is communicated or accepted like ``text/html``. It states whether connection will be kept alive or closed after submission of the header. It contains identification of the sender like ``User-Agent: Mozilla/5.0 (Windows NT 6.1)``, etc.
-
 Conclusion
 ~~~~~~~~~~
 
diff --git a/libraries/ESP8266HTTPClient/src/ESP8266HTTPClient.cpp b/libraries/ESP8266HTTPClient/src/ESP8266HTTPClient.cpp
index 44a413b450..74bc3be173 100644
--- a/libraries/ESP8266HTTPClient/src/ESP8266HTTPClient.cpp
+++ b/libraries/ESP8266HTTPClient/src/ESP8266HTTPClient.cpp
@@ -24,16 +24,10 @@
 #include <Arduino.h>
 
 #include "ESP8266HTTPClient.h"
-
-#if HTTPCLIENT_1_1_COMPATIBLE
 #include <ESP8266WiFi.h>
-#include <WiFiClientSecureAxTLS.h>
-#endif
-
 #include <StreamString.h>
 #include <base64.h>
 
-#if HTTPCLIENT_1_1_COMPATIBLE
 class TransportTraits
 {
 public:
@@ -54,31 +48,6 @@ class TransportTraits
     }
 };
 
-class TLSTraits : public TransportTraits
-{
-public:
-    TLSTraits(const String& fingerprint) :
-        _fingerprint(fingerprint)
-    {
-    }
-
-    std::unique_ptr<WiFiClient> create() override
-    {
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored  "-Wdeprecated-declarations"
-        return std::unique_ptr<WiFiClient>(new axTLS::WiFiClientSecure());
-#pragma GCC diagnostic pop
-    }
-
-    bool verify(WiFiClient& client, const char* host) override
-    {
-        auto wcs = static_cast<axTLS::WiFiClientSecure&>(client);
-        return wcs.verify(_fingerprint.c_str(), host);
-    }
-
-protected:
-    String _fingerprint;
-};
 
 class BearSSLTraits : public TransportTraits
 {
@@ -107,7 +76,6 @@ class BearSSLTraits : public TransportTraits
 protected:
     uint8_t _fingerprint[20];
 };
-#endif // HTTPCLIENT_1_1_COMPATIBLE
 
 /**
  * constructor
@@ -115,9 +83,7 @@ class BearSSLTraits : public TransportTraits
 HTTPClient::HTTPClient()
     : _client(nullptr), _userAgent(F("ESP8266HTTPClient"))
 {
-#if HTTPCLIENT_1_1_COMPATIBLE
     _tcpDeprecated.reset(nullptr);
-#endif
 }
 
 /**
@@ -151,13 +117,11 @@ void HTTPClient::clear()
  * @return success bool
  */
 bool HTTPClient::begin(WiFiClient &client, const String& url) {
-#if HTTPCLIENT_1_1_COMPATIBLE
     if(_tcpDeprecated) {
         DEBUG_HTTPCLIENT("[HTTP-Client][begin] mix up of new and deprecated api\n");
         _canReuse = false;
         end();
     }
-#endif
 
     _client = &client;
 
@@ -190,13 +154,11 @@ bool HTTPClient::begin(WiFiClient &client, const String& url) {
  */
 bool HTTPClient::begin(WiFiClient &client, const String& host, uint16_t port, const String& uri, bool https)
 {
-#if HTTPCLIENT_1_1_COMPATIBLE
     if(_tcpDeprecated) {
         DEBUG_HTTPCLIENT("[HTTP-Client][begin] mix up of new and deprecated api\n");
         _canReuse = false;
         end();
     }
-#endif
 
     _client = &client;
 
@@ -209,32 +171,6 @@ bool HTTPClient::begin(WiFiClient &client, const String& host, uint16_t port, co
 }
 
 
-#if HTTPCLIENT_1_1_COMPATIBLE
-bool HTTPClient::begin(String url, String httpsFingerprint)
-{
-    if(_client && !_tcpDeprecated) {
-        DEBUG_HTTPCLIENT("[HTTP-Client][begin] mix up of new and deprecated api\n");
-        _canReuse = false;
-        end();
-    }
-
-    if (httpsFingerprint.length() == 0) {
-        return false;
-    }
-    if (!beginInternal(url, "https")) {
-        return false;
-    }
-    _transportTraits = TransportTraitsPtr(new TLSTraits(httpsFingerprint));
-    if(!_transportTraits) {
-        DEBUG_HTTPCLIENT("[HTTP-Client][begin] could not create transport traits\n");
-        return false;
-    }
-
-    DEBUG_HTTPCLIENT("[HTTP-Client][begin] httpsFingerprint: %s\n", httpsFingerprint.c_str());
-    return true;
-}
-
-
 bool HTTPClient::begin(String url, const uint8_t httpsFingerprint[20])
 {
     if(_client && !_tcpDeprecated) {
@@ -279,7 +215,7 @@ bool HTTPClient::begin(String url)
     _transportTraits = TransportTraitsPtr(new TransportTraits());
     return true;
 }
-#endif // HTTPCLIENT_1_1_COMPATIBLE
+
 
 bool HTTPClient::beginInternal(const String& __url, const char* expectedProtocol)
 {
@@ -341,7 +277,7 @@ bool HTTPClient::beginInternal(const String& __url, const char* expectedProtocol
     return true;
 }
 
-#if HTTPCLIENT_1_1_COMPATIBLE
+
 bool HTTPClient::begin(String host, uint16_t port, String uri)
 {
     if(_client && !_tcpDeprecated) {
@@ -359,38 +295,6 @@ bool HTTPClient::begin(String host, uint16_t port, String uri)
     return true;
 }
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored  "-Wdeprecated-declarations"
-bool HTTPClient::begin(String host, uint16_t port, String uri, bool https, String httpsFingerprint)
-{
-    if (https) {
-        return begin(host, port, uri, httpsFingerprint);
-    } else {
-        return begin(host, port, uri);
-    }
-}
-#pragma GCC diagnostic pop
-
-bool HTTPClient::begin(String host, uint16_t port, String uri, String httpsFingerprint)
-{
-    if(_client && !_tcpDeprecated) {
-        DEBUG_HTTPCLIENT("[HTTP-Client][begin] mix up of new and deprecated api\n");
-        _canReuse = false;
-        end();
-    }
-
-    clear();
-    _host = host;
-    _port = port;
-    _uri = uri;
-
-    if (httpsFingerprint.length() == 0) {
-        return false;
-    }
-    _transportTraits = TransportTraitsPtr(new TLSTraits(httpsFingerprint));
-    DEBUG_HTTPCLIENT("[HTTP-Client][begin] host: %s port: %d url: %s httpsFingerprint: %s\n", host.c_str(), port, uri.c_str(), httpsFingerprint.c_str());
-    return true;
-}
 
 bool HTTPClient::begin(String host, uint16_t port, String uri, const uint8_t httpsFingerprint[20])
 {
@@ -413,7 +317,7 @@ bool HTTPClient::begin(String host, uint16_t port, String uri, const uint8_t htt
     DEBUG_HTTPCLIENT("\n");
     return true;
 }
-#endif // HTTPCLIENT_1_1_COMPATIBLE
+
 
 /**
  * end
@@ -449,12 +353,10 @@ void HTTPClient::disconnect(bool preserveClient)
                     _client = nullptr;
                 }
             }
-#if HTTPCLIENT_1_1_COMPATIBLE
             if(_tcpDeprecated) {
                 _transportTraits.reset(nullptr);
                 _tcpDeprecated.reset(nullptr);
             }
-#endif
         }
     } else {
         if (!preserveClient && _client) { // Also destroy _client if not connected()
@@ -1214,7 +1116,6 @@ bool HTTPClient::connect(void)
         return true;
     }
 
-#if HTTPCLIENT_1_1_COMPATIBLE
     if(!_client && _transportTraits) {
         _tcpDeprecated = _transportTraits->create();
         if(!_tcpDeprecated) {
@@ -1223,7 +1124,6 @@ bool HTTPClient::connect(void)
         }
         _client = _tcpDeprecated.get();
     }
-#endif
 
     if(!_client) {
         DEBUG_HTTPCLIENT("[HTTP-Client] connect: HTTPClient::begin was not called or returned error\n");
@@ -1239,14 +1139,11 @@ bool HTTPClient::connect(void)
 
     DEBUG_HTTPCLIENT("[HTTP-Client] connected to %s:%u\n", _host.c_str(), _port);
 
-#if HTTPCLIENT_1_1_COMPATIBLE
     if (_tcpDeprecated && !_transportTraits->verify(*_tcpDeprecated, _host.c_str())) {
         DEBUG_HTTPCLIENT("[HTTP-Client] transport level verify failed\n");
         _client->stop();
         return false;
     }
-#endif
-
 
 #ifdef ESP8266
     _client->setNoDelay(true);
diff --git a/libraries/ESP8266HTTPClient/src/ESP8266HTTPClient.h b/libraries/ESP8266HTTPClient/src/ESP8266HTTPClient.h
index acca34c12f..5dd3df5fb2 100644
--- a/libraries/ESP8266HTTPClient/src/ESP8266HTTPClient.h
+++ b/libraries/ESP8266HTTPClient/src/ESP8266HTTPClient.h
@@ -26,10 +26,6 @@
 #ifndef ESP8266HTTPClient_H_
 #define ESP8266HTTPClient_H_
 
-#ifndef HTTPCLIENT_1_1_COMPATIBLE
-#define HTTPCLIENT_1_1_COMPATIBLE 1
-#endif
-
 #include <memory>
 #include <Arduino.h>
 
@@ -149,10 +145,8 @@ typedef enum {
     HTTPC_FORCE_FOLLOW_REDIRECTS
 } followRedirects_t;
 
-#if HTTPCLIENT_1_1_COMPATIBLE
 class TransportTraits;
 typedef std::unique_ptr<TransportTraits> TransportTraitsPtr;
-#endif
 
 class StreamString;
 
@@ -169,19 +163,14 @@ class HTTPClient
     bool begin(WiFiClient &client, const String& url);
     bool begin(WiFiClient &client, const String& host, uint16_t port, const String& uri = "/", bool https = false);
 
-#if HTTPCLIENT_1_1_COMPATIBLE
     // Plain HTTP connection, unencrypted
     bool begin(String url)  __attribute__ ((deprecated));
     bool begin(String host, uint16_t port, String uri = "/")  __attribute__ ((deprecated));
-    // Use axTLS for secure HTTPS connection
-    bool begin(String url, String httpsFingerprint)  __attribute__ ((deprecated));
-    bool begin(String host, uint16_t port, String uri, String httpsFingerprint)  __attribute__ ((deprecated));
     // Use BearSSL for secure HTTPS connection
     bool begin(String url, const uint8_t httpsFingerprint[20])  __attribute__ ((deprecated));
     bool begin(String host, uint16_t port, String uri, const uint8_t httpsFingerprint[20])  __attribute__ ((deprecated));
     // deprecated, use the overload above instead
     bool begin(String host, uint16_t port, String uri, bool https, String httpsFingerprint)  __attribute__ ((deprecated));
-#endif
 
     void end(void);
 
@@ -249,10 +238,8 @@ class HTTPClient
     int writeToStreamDataBlock(Stream * stream, int len);
 
 
-#if HTTPCLIENT_1_1_COMPATIBLE
     TransportTraitsPtr _transportTraits;
     std::unique_ptr<WiFiClient> _tcpDeprecated;
-#endif
     WiFiClient* _client;
 
     /// request handling
diff --git a/libraries/ESP8266HTTPUpdateServer/examples/SecureHTTPSUpdater/SecureHTTPSUpdater.ino b/libraries/ESP8266HTTPUpdateServer/examples/SecureHTTPSUpdater/SecureHTTPSUpdater.ino
deleted file mode 100644
index a28d48de81..0000000000
--- a/libraries/ESP8266HTTPUpdateServer/examples/SecureHTTPSUpdater/SecureHTTPSUpdater.ino
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
-  SecureHTTPSUpdater - SSL encrypted, password-protected firmware update
-
-  This example starts a HTTPS server on the ESP8266 to allow firmware updates
-  to be performed.  All communication, including the username and password,
-  is encrypted via SSL.  Be sure to update the SSID and PASSWORD before running
-  to allow connection to your WiFi network.
-
-  IMPORTANT NOTES ABOUT SSL CERTIFICATES
-
-  1. USE/GENERATE YOUR OWN CERTIFICATES
-    While a sample, self-signed certificate is included in this example,
-    it is ABSOLUTELY VITAL that you use your own SSL certificate in any
-    real-world deployment.  Anyone with the certificate and key may be
-    able to decrypt your traffic, so your own keys should be kept in a
-    safe manner, not accessible on any public network.
-
-  2. HOW TO GENERATE YOUR OWN CERTIFICATE/KEY PAIR
-    A sample script, "make-self-signed-cert.sh" is provided in the
-    ESP8266WiFi/examples/WiFiHTTPSServer directory.  This script can be
-    modified (replace "your-name-here" with your Organization name).  Note
-    that this will be a *self-signed certificate* and will *NOT* be accepted
-    by default by most modern browsers.  They'll display something like,
-    "This certificate is from an untrusted source," or "Your connection is
-    not secure," or "Your connection is not private," and the user will
-    have to manully allow the browser to continue by using the
-    "Advanced/Add Exception" (FireFox) or "Advanced/Proceed" (Chrome) link.
-
-    You may also, of course, use a commercial, trusted SSL provider to
-    generate your certificate.  When requesting the certificate, you'll
-    need to specify that it use SHA256 and 1024 or 512 bits in order to
-    function with the axTLS implementation in the ESP8266.
-
-  Interactive usage:
-    Go to https://esp8266-webupdate.local/firmware, enter the username
-    and password, and the select a new BIN to upload.
-
-  To upload through terminal you can use:
-  curl -u admin:admin -F "image=@firmware.bin" esp8266-webupdate.local/firmware
-
-  Adapted by Earle F. Philhower, III, from the SecureWebUpdater.ino example.
-  This example is released into the public domain.
-*/
-
-// AXTLS is deprecated, do not use in new code.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-
-#include <ESP8266WiFi.h>
-#include <WiFiClient.h>
-#include <ESP8266WebServerSecure.h>
-#include <ESP8266mDNS.h>
-#include <ESP8266HTTPUpdateServer.h>
-#include <WiFiServerSecure.h>
-#include <WiFiServerSecureAxTLS.h>
-#include <WiFiClientSecure.h>
-#include <WiFiClientSecureAxTLS.h>
-
-#pragma GCC diagnostic pop
-
-#ifndef STASSID
-#define STASSID "your-ssid"
-#define STAPSK  "your-password"
-#endif
-
-const char* host = "esp8266-webupdate";
-const char* update_path = "/firmware";
-const char* update_username = "admin";
-const char* update_password = "admin";
-const char* ssid = STASSID;
-const char* password = STAPSK;
-
-axTLS::ESP8266WebServerSecure httpServer(443);
-axTLS::ESP8266HTTPUpdateServerSecure httpUpdater;
-
-// The certificate is stored in PMEM
-static const uint8_t x509[] PROGMEM = {
-  0x30, 0x82, 0x01, 0xc9, 0x30, 0x82, 0x01, 0x32, 0x02, 0x09, 0x00, 0xe6,
-  0x60, 0x8d, 0xa3, 0x47, 0x8f, 0x57, 0x7a, 0x30, 0x0d, 0x06, 0x09, 0x2a,
-  0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00, 0x30, 0x29,
-  0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x0a, 0x70,
-  0x73, 0x79, 0x63, 0x68, 0x6f, 0x70, 0x6c, 0x75, 0x67, 0x31, 0x12, 0x30,
-  0x10, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x09, 0x31, 0x32, 0x37, 0x2e,
-  0x30, 0x2e, 0x30, 0x2e, 0x31, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x37, 0x30,
-  0x32, 0x32, 0x34, 0x30, 0x38, 0x30, 0x35, 0x33, 0x36, 0x5a, 0x17, 0x0d,
-  0x33, 0x30, 0x31, 0x31, 0x30, 0x33, 0x30, 0x38, 0x30, 0x35, 0x33, 0x36,
-  0x5a, 0x30, 0x29, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x0a,
-  0x0c, 0x0a, 0x70, 0x73, 0x79, 0x63, 0x68, 0x6f, 0x70, 0x6c, 0x75, 0x67,
-  0x31, 0x12, 0x30, 0x10, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x09, 0x31,
-  0x32, 0x37, 0x2e, 0x30, 0x2e, 0x30, 0x2e, 0x31, 0x30, 0x81, 0x9f, 0x30,
-  0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01,
-  0x05, 0x00, 0x03, 0x81, 0x8d, 0x00, 0x30, 0x81, 0x89, 0x02, 0x81, 0x81,
-  0x00, 0xb6, 0x59, 0xd0, 0x57, 0xbc, 0x3e, 0xb9, 0xa0, 0x6c, 0xf5, 0xd5,
-  0x46, 0x49, 0xaa, 0x9a, 0xb3, 0xbf, 0x09, 0xa9, 0xbb, 0x82, 0x3b, 0xdf,
-  0xb7, 0xe3, 0x5a, 0x8e, 0x31, 0xf7, 0x27, 0xdf, 0xaa, 0xed, 0xa3, 0xd6,
-  0xf6, 0x74, 0x35, 0xfc, 0x8d, 0x0b, 0xbc, 0xa2, 0x96, 0x10, 0x57, 0xe8,
-  0xb2, 0xaa, 0x94, 0xf2, 0x47, 0x12, 0x4e, 0x3f, 0x7c, 0x5e, 0x90, 0xfe,
-  0xad, 0x75, 0x88, 0xca, 0x7b, 0x9a, 0x18, 0x15, 0xbe, 0x3d, 0xe0, 0x31,
-  0xb5, 0x45, 0x7f, 0xe7, 0x9d, 0x22, 0x99, 0x65, 0xba, 0x63, 0x70, 0x81,
-  0x3b, 0x37, 0x22, 0x97, 0x64, 0xc5, 0x57, 0x8c, 0x98, 0x9c, 0x10, 0x36,
-  0x98, 0xf0, 0x0b, 0x19, 0x28, 0x16, 0x9a, 0x40, 0x31, 0x5f, 0xbc, 0xd9,
-  0x8e, 0x73, 0x68, 0xe1, 0x6a, 0x5d, 0x91, 0x0b, 0x4f, 0x73, 0xa4, 0x6b,
-  0x8f, 0xa5, 0xad, 0x12, 0x09, 0x32, 0xa7, 0x66, 0x3b, 0x02, 0x03, 0x01,
-  0x00, 0x01, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d,
-  0x01, 0x01, 0x05, 0x05, 0x00, 0x03, 0x81, 0x81, 0x00, 0x1b, 0x46, 0x78,
-  0xd1, 0xfa, 0x21, 0xc1, 0xd6, 0x75, 0xc0, 0x83, 0x59, 0x57, 0x05, 0xd5,
-  0xae, 0xf8, 0x8c, 0x78, 0x03, 0x65, 0x3b, 0xbf, 0xef, 0x70, 0x3f, 0x78,
-  0xc6, 0xe1, 0x5a, 0xac, 0xb1, 0x93, 0x5b, 0x41, 0x35, 0x45, 0x47, 0xf8,
-  0x07, 0x86, 0x40, 0x34, 0xa2, 0x9e, 0x2a, 0x16, 0x8d, 0xea, 0xf9, 0x1e,
-  0x1f, 0xd7, 0x70, 0xb4, 0x28, 0x6b, 0xd8, 0xf5, 0x3f, 0x33, 0x3f, 0xc2,
-  0x2c, 0x69, 0xf2, 0xa3, 0x54, 0x4d, 0xbf, 0x7d, 0xf9, 0xde, 0x05, 0x0c,
-  0x9c, 0xe3, 0x1b, 0x72, 0x07, 0x7b, 0x41, 0x76, 0x1a, 0x57, 0x03, 0x5d,
-  0xb2, 0xff, 0x4c, 0x17, 0xbd, 0xd7, 0x73, 0x32, 0x98, 0x26, 0x6b, 0x2c,
-  0xc4, 0xbf, 0x6e, 0x01, 0x36, 0x8b, 0xbf, 0x00, 0x48, 0x9c, 0xfb, 0x3d,
-  0x7d, 0x76, 0x1f, 0x55, 0x96, 0x43, 0xc5, 0x4e, 0xc1, 0xa3, 0xa1, 0x6a,
-  0x94, 0x5f, 0x84, 0x3a, 0xdd
-};
-
-// And so is the key.  These could also be in DRAM
-static const uint8_t rsakey[] PROGMEM = {
-  0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xb6,
-  0x59, 0xd0, 0x57, 0xbc, 0x3e, 0xb9, 0xa0, 0x6c, 0xf5, 0xd5, 0x46, 0x49,
-  0xaa, 0x9a, 0xb3, 0xbf, 0x09, 0xa9, 0xbb, 0x82, 0x3b, 0xdf, 0xb7, 0xe3,
-  0x5a, 0x8e, 0x31, 0xf7, 0x27, 0xdf, 0xaa, 0xed, 0xa3, 0xd6, 0xf6, 0x74,
-  0x35, 0xfc, 0x8d, 0x0b, 0xbc, 0xa2, 0x96, 0x10, 0x57, 0xe8, 0xb2, 0xaa,
-  0x94, 0xf2, 0x47, 0x12, 0x4e, 0x3f, 0x7c, 0x5e, 0x90, 0xfe, 0xad, 0x75,
-  0x88, 0xca, 0x7b, 0x9a, 0x18, 0x15, 0xbe, 0x3d, 0xe0, 0x31, 0xb5, 0x45,
-  0x7f, 0xe7, 0x9d, 0x22, 0x99, 0x65, 0xba, 0x63, 0x70, 0x81, 0x3b, 0x37,
-  0x22, 0x97, 0x64, 0xc5, 0x57, 0x8c, 0x98, 0x9c, 0x10, 0x36, 0x98, 0xf0,
-  0x0b, 0x19, 0x28, 0x16, 0x9a, 0x40, 0x31, 0x5f, 0xbc, 0xd9, 0x8e, 0x73,
-  0x68, 0xe1, 0x6a, 0x5d, 0x91, 0x0b, 0x4f, 0x73, 0xa4, 0x6b, 0x8f, 0xa5,
-  0xad, 0x12, 0x09, 0x32, 0xa7, 0x66, 0x3b, 0x02, 0x03, 0x01, 0x00, 0x01,
-  0x02, 0x81, 0x81, 0x00, 0xa8, 0x55, 0xf9, 0x33, 0x45, 0x20, 0x52, 0x94,
-  0x7a, 0x81, 0xe6, 0xc4, 0xe0, 0x34, 0x92, 0x63, 0xe4, 0xb3, 0xb2, 0xf0,
-  0xda, 0xa5, 0x13, 0x3d, 0xda, 0xb0, 0x3a, 0x1c, 0x7e, 0x21, 0x5d, 0x25,
-  0x9a, 0x03, 0x69, 0xea, 0x52, 0x15, 0x94, 0x73, 0x50, 0xa6, 0x6f, 0x21,
-  0x41, 0x2d, 0x26, 0x2f, 0xe9, 0xb1, 0x5e, 0x87, 0xa5, 0xaa, 0x7e, 0x88,
-  0xfd, 0x73, 0xb4, 0xe7, 0xc4, 0x5c, 0xe7, 0x2d, 0xeb, 0x9e, 0x6b, 0xe1,
-  0xf1, 0x38, 0x45, 0xf4, 0x10, 0x12, 0xac, 0x79, 0x40, 0x72, 0xf0, 0x45,
-  0x89, 0x5c, 0x9d, 0x8b, 0x7b, 0x5d, 0x69, 0xd9, 0x11, 0xf9, 0x25, 0xff,
-  0xe1, 0x2a, 0xb3, 0x6d, 0x49, 0x18, 0x8d, 0x38, 0x0a, 0x6f, 0x0f, 0xbd,
-  0x48, 0xd0, 0xdd, 0xcb, 0x41, 0x5c, 0x2a, 0x75, 0xa0, 0x51, 0x43, 0x4a,
-  0x0b, 0xf6, 0xa2, 0xd2, 0xe9, 0xda, 0x37, 0xca, 0x2d, 0xd7, 0x22, 0x01,
-  0x02, 0x41, 0x00, 0xe7, 0x11, 0xea, 0x93, 0xf4, 0x0b, 0xe6, 0xa0, 0x1a,
-  0x57, 0x2d, 0xee, 0x96, 0x05, 0x5c, 0xa1, 0x08, 0x8f, 0x9c, 0xac, 0x9a,
-  0x72, 0x60, 0x5a, 0x41, 0x2a, 0x92, 0x38, 0x36, 0xa5, 0xfe, 0xb9, 0x35,
-  0xb2, 0x06, 0xbb, 0x02, 0x58, 0xc8, 0x93, 0xd6, 0x09, 0x6f, 0x57, 0xd7,
-  0xc1, 0x2e, 0x90, 0xb3, 0x09, 0xdd, 0x0c, 0x63, 0x99, 0x91, 0xb7, 0xe4,
-  0xcc, 0x6f, 0x78, 0x24, 0xbc, 0x3b, 0x7b, 0x02, 0x41, 0x00, 0xca, 0x06,
-  0x4a, 0x09, 0x36, 0x08, 0xaa, 0x27, 0x08, 0x91, 0x86, 0xc5, 0x17, 0x14,
-  0x6e, 0x24, 0x9a, 0x86, 0xd1, 0xbc, 0x41, 0xb1, 0x42, 0x5e, 0xe8, 0x80,
-  0x5a, 0x8f, 0x7c, 0x9b, 0xe8, 0xcc, 0x28, 0xe1, 0xa2, 0x8f, 0xe9, 0xdc,
-  0x60, 0xd5, 0x00, 0x34, 0x76, 0x32, 0x36, 0x00, 0x93, 0x69, 0x6b, 0xab,
-  0xc6, 0x8b, 0x70, 0x95, 0x4e, 0xc2, 0x27, 0x4a, 0x24, 0x73, 0xbf, 0xcd,
-  0x24, 0x41, 0x02, 0x40, 0x40, 0x46, 0x75, 0x90, 0x0e, 0x54, 0xb9, 0x24,
-  0x53, 0xef, 0x68, 0x31, 0x73, 0xbd, 0xae, 0x14, 0x85, 0x43, 0x1d, 0x7b,
-  0xcd, 0xc2, 0x7f, 0x16, 0xdc, 0x05, 0xb1, 0x82, 0xbd, 0x80, 0xd3, 0x28,
-  0x45, 0xcd, 0x6d, 0x9d, 0xdb, 0x7b, 0x42, 0xe0, 0x0c, 0xab, 0xb7, 0x33,
-  0x22, 0x2a, 0xf4, 0x7e, 0xff, 0xae, 0x80, 0xb4, 0x8f, 0x88, 0x0a, 0x46,
-  0xb2, 0xf8, 0x43, 0x11, 0x92, 0x76, 0x61, 0xbd, 0x02, 0x40, 0x5c, 0x86,
-  0x3a, 0xdc, 0x33, 0x1a, 0x0e, 0xcb, 0xa7, 0xb9, 0xf6, 0xae, 0x47, 0x5e,
-  0xbc, 0xff, 0x18, 0xa2, 0x8c, 0x66, 0x1a, 0xf4, 0x13, 0x00, 0xa2, 0x9d,
-  0x3e, 0x5c, 0x9e, 0xe6, 0x4c, 0xdd, 0x4c, 0x0f, 0xe2, 0xc2, 0xe4, 0x89,
-  0x60, 0xf3, 0xcc, 0x8f, 0x3a, 0x5e, 0xce, 0xaa, 0xbe, 0xd8, 0xb6, 0x4e,
-  0x4a, 0xb5, 0x4c, 0x0f, 0xa5, 0xad, 0x78, 0x0f, 0x15, 0xd8, 0xc9, 0x4c,
-  0x2b, 0xc1, 0x02, 0x40, 0x4e, 0xe9, 0x78, 0x48, 0x94, 0x11, 0x75, 0xc1,
-  0xa2, 0xc7, 0xff, 0xf0, 0x73, 0xa2, 0x93, 0xd7, 0x67, 0xc7, 0xf8, 0x96,
-  0xac, 0x15, 0xaa, 0xe5, 0x5d, 0x18, 0x18, 0x29, 0xa9, 0x9a, 0xfc, 0xac,
-  0x48, 0x4d, 0xa0, 0xca, 0xa2, 0x34, 0x09, 0x7c, 0x13, 0x22, 0x4c, 0xfc,
-  0x31, 0x75, 0xa0, 0x21, 0x1e, 0x7a, 0x91, 0xbc, 0xb1, 0x97, 0xde, 0x43,
-  0xe1, 0x40, 0x2b, 0xe3, 0xbd, 0x98, 0x44, 0xad
-};
-
-void setup() {
-
-  Serial.begin(115200);
-  Serial.println();
-  Serial.println("Booting Sketch...");
-  WiFi.mode(WIFI_AP_STA);
-  WiFi.begin(ssid, password);
-
-  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
-    WiFi.begin(ssid, password);
-    Serial.println("WiFi failed, retrying.");
-  }
-
-  MDNS.begin(host);
-
-  httpServer.getServer().setServerKeyAndCert_P(rsakey, sizeof(rsakey), x509, sizeof(x509));
-  httpUpdater.setup(&httpServer, update_path, update_username, update_password);
-  httpServer.begin();
-
-  MDNS.addService("https", "tcp", 443);
-  Serial.printf("HTTPSUpdateServer ready!\nOpen https://%s.local%s in "\
-                "your browser and login with username '%s' and password "\
-                "'%s'\n", host, update_path, update_username, update_password);
-}
-
-void loop() {
-  httpServer.handleClient();
-  MDNS.update();
-}
diff --git a/libraries/ESP8266HTTPUpdateServer/src/ESP8266HTTPUpdateServer.h b/libraries/ESP8266HTTPUpdateServer/src/ESP8266HTTPUpdateServer.h
index 73ceaf767f..53f03899ca 100644
--- a/libraries/ESP8266HTTPUpdateServer/src/ESP8266HTTPUpdateServer.h
+++ b/libraries/ESP8266HTTPUpdateServer/src/ESP8266HTTPUpdateServer.h
@@ -58,8 +58,4 @@ namespace BearSSL {
 using ESP8266HTTPUpdateServerSecure = esp8266httpupdateserver::ESP8266HTTPUpdateServerTemplate<WiFiServerSecure>;
 };
 
-namespace axTLS {
-using ESP8266HTTPUpdateServerSecure = esp8266httpupdateserver::ESP8266HTTPUpdateServerTemplate<WiFiServerSecure>;
-};
-
 #endif
diff --git a/libraries/ESP8266WebServer/examples/HelloServerSecure/HelloServerSecure.ino b/libraries/ESP8266WebServer/examples/HelloServerSecure/HelloServerSecure.ino
deleted file mode 100644
index 87c34ccb58..0000000000
--- a/libraries/ESP8266WebServer/examples/HelloServerSecure/HelloServerSecure.ino
+++ /dev/null
@@ -1,185 +0,0 @@
-/*
-  HelloServerSecure - Simple HTTPS server example
-
-  This example demonstrates a basic ESP8266WebServerSecure HTTPS server
-  that can serve "/" and "/inline" and generate detailed 404 (not found)
-  HTTP respoinses.  Be sure to update the SSID and PASSWORD before running
-  to allow connection to your WiFi network.
-
-  IMPORTANT NOTES ABOUT SSL CERTIFICATES
-
-  1. USE/GENERATE YOUR OWN CERTIFICATES
-    While a sample, self-signed certificate is included in this example,
-    it is ABSOLUTELY VITAL that you use your own SSL certificate in any
-    real-world deployment.  Anyone with the certificate and key may be
-    able to decrypt your traffic, so your own keys should be kept in a
-    safe manner, not accessible on any public network.
-
-  2. HOW TO GENERATE YOUR OWN CERTIFICATE/KEY PAIR
-    A sample script, "make-self-signed-cert.sh" is provided in the
-    ESP8266WiFi/examples/WiFiHTTPSServer directory.  This script can be
-    modified (replace "your-name-here" with your Organization name).  Note
-    that this will be a *self-signed certificate* and will *NOT* be accepted
-    by default by most modern browsers.  They'll display something like,
-    "This certificate is from an untrusted source," or "Your connection is
-    not secure," or "Your connection is not private," and the user will
-    have to manully allow the browser to continue by using the
-    "Advanced/Add Exception" (FireFox) or "Advanced/Proceed" (Chrome) link.
-
-    You may also, of course, use a commercial, trusted SSL provider to
-    generate your certificate.  When requesting the certificate, you'll
-    need to specify that it use SHA256 and 1024 or 512 bits in order to
-    function with the axTLS implementation in the ESP8266.
-
-  Interactive usage:
-    Go to https://esp8266-webupdate.local/firmware, enter the username
-    and password, and the select a new BIN to upload.
-
-  To upload through terminal you can use:
-  curl -u admin:admin -F "image=@firmware.bin" esp8266-webupdate.local/firmware
-
-  Adapted by Earle F. Philhower, III, from the HelloServer.ino example.
-  This example is released into the public domain.
-*/
-#include <ESP8266WiFi.h>
-#include <WiFiClient.h>
-#include <ESP8266WebServerSecure.h>
-#include <ESP8266mDNS.h>
-
-#ifndef STASSID
-#define STASSID "your-ssid"
-#define STAPSK  "your-password"
-#endif
-
-const char* ssid = STASSID;
-const char* password = STAPSK;
-
-ESP8266WebServerSecure server(443);
-
-// The certificate is stored in PMEM
-static const uint8_t x509[] PROGMEM = {
-  0x30, 0x82, 0x01, 0x3d, 0x30, 0x81, 0xe8, 0x02, 0x09, 0x00, 0xfe, 0x56,
-  0x46, 0xf2, 0x78, 0xc6, 0x51, 0x17, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86,
-  0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x30, 0x26, 0x31,
-  0x10, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x07, 0x45, 0x53,
-  0x50, 0x38, 0x32, 0x36, 0x36, 0x31, 0x12, 0x30, 0x10, 0x06, 0x03, 0x55,
-  0x04, 0x03, 0x0c, 0x09, 0x31, 0x32, 0x37, 0x2e, 0x30, 0x2e, 0x30, 0x2e,
-  0x31, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x37, 0x30, 0x33, 0x31, 0x38, 0x31,
-  0x34, 0x34, 0x39, 0x31, 0x38, 0x5a, 0x17, 0x0d, 0x33, 0x30, 0x31, 0x31,
-  0x32, 0x35, 0x31, 0x34, 0x34, 0x39, 0x31, 0x38, 0x5a, 0x30, 0x26, 0x31,
-  0x10, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x07, 0x45, 0x53,
-  0x50, 0x38, 0x32, 0x36, 0x36, 0x31, 0x12, 0x30, 0x10, 0x06, 0x03, 0x55,
-  0x04, 0x03, 0x0c, 0x09, 0x31, 0x32, 0x37, 0x2e, 0x30, 0x2e, 0x30, 0x2e,
-  0x31, 0x30, 0x5c, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
-  0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x4b, 0x00, 0x30, 0x48, 0x02,
-  0x41, 0x00, 0xc6, 0x72, 0x6c, 0x12, 0xe1, 0x20, 0x4d, 0x10, 0x0c, 0xf7,
-  0x3a, 0x2a, 0x5a, 0x49, 0xe2, 0x2d, 0xc9, 0x7a, 0x63, 0x1d, 0xef, 0xc6,
-  0xbb, 0xa3, 0xd6, 0x6f, 0x59, 0xcb, 0xd5, 0xf6, 0xbe, 0x34, 0x83, 0x33,
-  0x50, 0x80, 0xec, 0x49, 0x63, 0xbf, 0xee, 0x59, 0x94, 0x67, 0x8b, 0x8d,
-  0x81, 0x85, 0x23, 0x24, 0x06, 0x52, 0x76, 0x55, 0x9d, 0x18, 0x09, 0xb3,
-  0x3c, 0x10, 0x40, 0x05, 0x01, 0xf3, 0x02, 0x03, 0x01, 0x00, 0x01, 0x30,
-  0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b,
-  0x05, 0x00, 0x03, 0x41, 0x00, 0x69, 0xdc, 0x6c, 0x9b, 0xa7, 0x62, 0x57,
-  0x7e, 0x03, 0x01, 0x45, 0xad, 0x9a, 0x83, 0x90, 0x3a, 0xe7, 0xdf, 0xe8,
-  0x8f, 0x46, 0x00, 0xd3, 0x5f, 0x2b, 0x0a, 0xde, 0x92, 0x1b, 0xc5, 0x04,
-  0xc5, 0xc0, 0x76, 0xf4, 0xf6, 0x08, 0x36, 0x97, 0x27, 0x82, 0xf1, 0x60,
-  0x76, 0xc2, 0xcd, 0x67, 0x6c, 0x4b, 0x6c, 0xca, 0xfd, 0x97, 0xfd, 0x33,
-  0x9e, 0x12, 0x67, 0x6b, 0x98, 0x7e, 0xd5, 0x80, 0x8f
-};
-
-// And so is the key.  These could also be in DRAM
-static const uint8_t rsakey[] PROGMEM = {
-  0x30, 0x82, 0x01, 0x3a, 0x02, 0x01, 0x00, 0x02, 0x41, 0x00, 0xc6, 0x72,
-  0x6c, 0x12, 0xe1, 0x20, 0x4d, 0x10, 0x0c, 0xf7, 0x3a, 0x2a, 0x5a, 0x49,
-  0xe2, 0x2d, 0xc9, 0x7a, 0x63, 0x1d, 0xef, 0xc6, 0xbb, 0xa3, 0xd6, 0x6f,
-  0x59, 0xcb, 0xd5, 0xf6, 0xbe, 0x34, 0x83, 0x33, 0x50, 0x80, 0xec, 0x49,
-  0x63, 0xbf, 0xee, 0x59, 0x94, 0x67, 0x8b, 0x8d, 0x81, 0x85, 0x23, 0x24,
-  0x06, 0x52, 0x76, 0x55, 0x9d, 0x18, 0x09, 0xb3, 0x3c, 0x10, 0x40, 0x05,
-  0x01, 0xf3, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x40, 0x35, 0x0b, 0x74,
-  0xd3, 0xff, 0x15, 0x51, 0x44, 0x0f, 0x13, 0x2e, 0x9b, 0x0f, 0x93, 0x5c,
-  0x3f, 0xfc, 0xf1, 0x17, 0xf9, 0x72, 0x94, 0x5e, 0xa7, 0xc6, 0xb3, 0xf0,
-  0xfe, 0xc9, 0x6c, 0xb1, 0x1e, 0x83, 0xb3, 0xc6, 0x45, 0x3a, 0x25, 0x60,
-  0x7c, 0x3d, 0x92, 0x7d, 0x53, 0xec, 0x49, 0x8d, 0xb5, 0x45, 0x10, 0x99,
-  0x9b, 0xc6, 0x22, 0x3a, 0x68, 0xc7, 0x13, 0x4e, 0xb6, 0x04, 0x61, 0x21,
-  0x01, 0x02, 0x21, 0x00, 0xea, 0x8c, 0x21, 0xd4, 0x7f, 0x3f, 0xb6, 0x91,
-  0xfa, 0xf8, 0xb9, 0x2d, 0xcb, 0x36, 0x36, 0x02, 0x5f, 0xf0, 0x0c, 0x6e,
-  0x87, 0xaa, 0x5c, 0x14, 0xf6, 0x56, 0x8e, 0x12, 0x92, 0x25, 0xde, 0xb3,
-  0x02, 0x21, 0x00, 0xd8, 0x99, 0x01, 0xf1, 0x04, 0x0b, 0x98, 0xa3, 0x71,
-  0x56, 0x1d, 0xea, 0x6f, 0x45, 0xd1, 0x36, 0x70, 0x76, 0x8b, 0xab, 0x69,
-  0x30, 0x58, 0x9c, 0xe0, 0x45, 0x97, 0xe7, 0xb6, 0xb5, 0xef, 0xc1, 0x02,
-  0x21, 0x00, 0xa2, 0x01, 0x06, 0xc0, 0xf2, 0xdf, 0xbc, 0x28, 0x1a, 0xb4,
-  0xbf, 0x9b, 0x5c, 0xd8, 0x65, 0xf7, 0xbf, 0xf2, 0x5b, 0x73, 0xe0, 0xeb,
-  0x0f, 0xcd, 0x3e, 0xd5, 0x4c, 0x2e, 0x91, 0x99, 0xec, 0xb7, 0x02, 0x20,
-  0x4b, 0x9d, 0x46, 0xd7, 0x3c, 0x01, 0x4c, 0x5d, 0x2a, 0xb0, 0xd4, 0xaa,
-  0xc6, 0x03, 0xca, 0xa0, 0xc5, 0xac, 0x2c, 0xe0, 0x3f, 0x4d, 0x98, 0x71,
-  0xd3, 0xbd, 0x97, 0xe5, 0x55, 0x9c, 0xb8, 0x41, 0x02, 0x20, 0x02, 0x42,
-  0x9f, 0xd1, 0x06, 0x35, 0x3b, 0x42, 0xf5, 0x64, 0xaf, 0x6d, 0xbf, 0xcd,
-  0x2c, 0x3a, 0xcd, 0x0a, 0x9a, 0x4d, 0x7c, 0xad, 0x29, 0xd6, 0x36, 0x57,
-  0xd5, 0xdf, 0x34, 0xeb, 0x26, 0x03
-};
-
-const int led = 13;
-
-void handleRoot() {
-  digitalWrite(led, 1);
-  server.send(200, "text/plain", "Hello from esp8266 over HTTPS!");
-  digitalWrite(led, 0);
-}
-
-void handleNotFound() {
-  digitalWrite(led, 1);
-  String message = "File Not Found\n\n";
-  message += "URI: ";
-  message += server.uri();
-  message += "\nMethod: ";
-  message += (server.method() == HTTP_GET) ? "GET" : "POST";
-  message += "\nArguments: ";
-  message += server.args();
-  message += "\n";
-  for (uint8_t i = 0; i < server.args(); i++) {
-    message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
-  }
-  server.send(404, "text/plain", message);
-  digitalWrite(led, 0);
-}
-
-void setup(void) {
-  pinMode(led, OUTPUT);
-  digitalWrite(led, 0);
-  Serial.begin(115200);
-  WiFi.begin(ssid, password);
-  Serial.println("");
-
-  // Wait for connection
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(500);
-    Serial.print(".");
-  }
-  Serial.println("");
-  Serial.print("Connected to ");
-  Serial.println(ssid);
-  Serial.print("IP address: ");
-  Serial.println(WiFi.localIP());
-
-  if (MDNS.begin("esp8266")) {
-    Serial.println("MDNS responder started");
-  }
-
-  server.getServer().setServerKeyAndCert_P(rsakey, sizeof(rsakey), x509, sizeof(x509));
-
-  server.on("/", handleRoot);
-
-  server.on("/inline", []() {
-    server.send(200, "text/plain", "this works as well");
-  });
-
-  server.onNotFound(handleNotFound);
-
-  server.begin();
-  Serial.println("HTTPS server started");
-}
-
-void loop(void) {
-  server.handleClient();
-  MDNS.update();
-}
diff --git a/libraries/ESP8266WebServer/src/ESP8266WebServerSecure.h b/libraries/ESP8266WebServer/src/ESP8266WebServerSecure.h
index 4ab02bff07..1d72490f0a 100644
--- a/libraries/ESP8266WebServer/src/ESP8266WebServerSecure.h
+++ b/libraries/ESP8266WebServer/src/ESP8266WebServerSecure.h
@@ -22,10 +22,6 @@
 #include <ESP8266WebServer.h>
 #include <WiFiClientSecure.h>
 
-namespace axTLS {
-  using ESP8266WebServerSecure = esp8266webserver::ESP8266WebServerTemplate<WiFiServerSecure>;
-};
-
 namespace BearSSL {
   using ESP8266WebServerSecure = esp8266webserver::ESP8266WebServerTemplate<WiFiServerSecure>;
 };
diff --git a/libraries/ESP8266WiFi/examples/HTTPSRequestAxTLS/HTTPSRequestAxTLS.ino b/libraries/ESP8266WiFi/examples/HTTPSRequestAxTLS/HTTPSRequestAxTLS.ino
deleted file mode 100644
index 0830491994..0000000000
--- a/libraries/ESP8266WiFi/examples/HTTPSRequestAxTLS/HTTPSRequestAxTLS.ino
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
-    HTTP over TLS (HTTPS) example sketch
-
-    This example demonstrates how to use
-    WiFiClientSecure class to access HTTPS API.
-    We fetch and display the status of
-    esp8266/Arduino project continuous integration
-    build.
-
-    Limitations:
-      only RSA certificates
-      no support of Perfect Forward Secrecy (PFS)
-      TLSv1.2 is supported since version 2.4.0-rc1
-
-    Created by Ivan Grokhotkov, 2015.
-    This example is in public domain.
-*/
-
-#define USING_AXTLS
-#include <ESP8266WiFi.h>
-
-// force use of AxTLS (BearSSL is now default)
-#include <WiFiClientSecureAxTLS.h>
-using namespace axTLS;
-
-#ifndef STASSID
-#define STASSID "your-ssid"
-#define STAPSK  "your-password"
-#endif
-
-const char* ssid = STASSID;
-const char* password = STAPSK;
-
-const char* host = "api.github.com";
-const int httpsPort = 443;
-
-// Use web browser to view and copy
-// SHA1 fingerprint of the certificate
-const char* fingerprint = "5F F1 60 31 09 04 3E F2 90 D2 B0 8A 50 38 04 E8 37 9F BC 76";
-
-void setup() {
-  Serial.begin(115200);
-  Serial.println();
-  Serial.print("connecting to ");
-  Serial.println(ssid);
-  WiFi.mode(WIFI_STA);
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(500);
-    Serial.print(".");
-  }
-  Serial.println("");
-  Serial.println("WiFi connected");
-  Serial.println("IP address: ");
-  Serial.println(WiFi.localIP());
-
-  // Use WiFiClientSecure class to create TLS connection
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored  "-Wdeprecated-declarations"
-  WiFiClientSecure client;
-#pragma GCC diagnostic pop
-  Serial.print("connecting to ");
-  Serial.println(host);
-  if (!client.connect(host, httpsPort)) {
-    Serial.println("connection failed");
-    return;
-  }
-
-  if (client.verify(fingerprint, host)) {
-    Serial.println("certificate matches");
-  } else {
-    Serial.println("certificate doesn't match");
-  }
-
-  String url = "/repos/esp8266/Arduino/commits/master/status";
-  Serial.print("requesting URL: ");
-  Serial.println(url);
-
-  client.print(String("GET ") + url + " HTTP/1.1\r\n" +
-               "Host: " + host + "\r\n" +
-               "User-Agent: BuildFailureDetectorESP8266\r\n" +
-               "Connection: close\r\n\r\n");
-
-  Serial.println("request sent");
-  while (client.connected()) {
-    String line = client.readStringUntil('\n');
-    if (line == "\r") {
-      Serial.println("headers received");
-      break;
-    }
-  }
-  String line = client.readStringUntil('\n');
-  if (line.startsWith("{\"state\":\"success\"")) {
-    Serial.println("esp8266/Arduino CI successfull!");
-  } else {
-    Serial.println("esp8266/Arduino CI has failed");
-  }
-  Serial.println("reply was:");
-  Serial.println("==========");
-  Serial.println(line);
-  Serial.println("==========");
-  Serial.println("closing connection");
-}
-
-void loop() {
-}
diff --git a/libraries/ESP8266WiFi/examples/HTTPSRequestCACertAxTLS/CACert.ino b/libraries/ESP8266WiFi/examples/HTTPSRequestCACertAxTLS/CACert.ino
deleted file mode 100644
index 9b84ed3b7a..0000000000
--- a/libraries/ESP8266WiFi/examples/HTTPSRequestCACertAxTLS/CACert.ino
+++ /dev/null
@@ -1,86 +0,0 @@
-
-const unsigned char caCert[] PROGMEM = {
-  0x30, 0x82, 0x03, 0xc5, 0x30, 0x82, 0x02, 0xad, 0xa0, 0x03, 0x02, 0x01,
-  0x02, 0x02, 0x10, 0x02, 0xac, 0x5c, 0x26, 0x6a, 0x0b, 0x40, 0x9b, 0x8f,
-  0x0b, 0x79, 0xf2, 0xae, 0x46, 0x25, 0x77, 0x30, 0x0d, 0x06, 0x09, 0x2a,
-  0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00, 0x30, 0x6c,
-  0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55,
-  0x53, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x0c,
-  0x44, 0x69, 0x67, 0x69, 0x43, 0x65, 0x72, 0x74, 0x20, 0x49, 0x6e, 0x63,
-  0x31, 0x19, 0x30, 0x17, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x13, 0x10, 0x77,
-  0x77, 0x77, 0x2e, 0x64, 0x69, 0x67, 0x69, 0x63, 0x65, 0x72, 0x74, 0x2e,
-  0x63, 0x6f, 0x6d, 0x31, 0x2b, 0x30, 0x29, 0x06, 0x03, 0x55, 0x04, 0x03,
-  0x13, 0x22, 0x44, 0x69, 0x67, 0x69, 0x43, 0x65, 0x72, 0x74, 0x20, 0x48,
-  0x69, 0x67, 0x68, 0x20, 0x41, 0x73, 0x73, 0x75, 0x72, 0x61, 0x6e, 0x63,
-  0x65, 0x20, 0x45, 0x56, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x43, 0x41,
-  0x30, 0x1e, 0x17, 0x0d, 0x30, 0x36, 0x31, 0x31, 0x31, 0x30, 0x30, 0x30,
-  0x30, 0x30, 0x30, 0x30, 0x5a, 0x17, 0x0d, 0x33, 0x31, 0x31, 0x31, 0x31,
-  0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x30, 0x6c, 0x31, 0x0b,
-  0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31,
-  0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x0c, 0x44, 0x69,
-  0x67, 0x69, 0x43, 0x65, 0x72, 0x74, 0x20, 0x49, 0x6e, 0x63, 0x31, 0x19,
-  0x30, 0x17, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x13, 0x10, 0x77, 0x77, 0x77,
-  0x2e, 0x64, 0x69, 0x67, 0x69, 0x63, 0x65, 0x72, 0x74, 0x2e, 0x63, 0x6f,
-  0x6d, 0x31, 0x2b, 0x30, 0x29, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x22,
-  0x44, 0x69, 0x67, 0x69, 0x43, 0x65, 0x72, 0x74, 0x20, 0x48, 0x69, 0x67,
-  0x68, 0x20, 0x41, 0x73, 0x73, 0x75, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x20,
-  0x45, 0x56, 0x20, 0x52, 0x6f, 0x6f, 0x74, 0x20, 0x43, 0x41, 0x30, 0x82,
-  0x01, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d,
-  0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82,
-  0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xc6, 0xcc, 0xe5, 0x73, 0xe6,
-  0xfb, 0xd4, 0xbb, 0xe5, 0x2d, 0x2d, 0x32, 0xa6, 0xdf, 0xe5, 0x81, 0x3f,
-  0xc9, 0xcd, 0x25, 0x49, 0xb6, 0x71, 0x2a, 0xc3, 0xd5, 0x94, 0x34, 0x67,
-  0xa2, 0x0a, 0x1c, 0xb0, 0x5f, 0x69, 0xa6, 0x40, 0xb1, 0xc4, 0xb7, 0xb2,
-  0x8f, 0xd0, 0x98, 0xa4, 0xa9, 0x41, 0x59, 0x3a, 0xd3, 0xdc, 0x94, 0xd6,
-  0x3c, 0xdb, 0x74, 0x38, 0xa4, 0x4a, 0xcc, 0x4d, 0x25, 0x82, 0xf7, 0x4a,
-  0xa5, 0x53, 0x12, 0x38, 0xee, 0xf3, 0x49, 0x6d, 0x71, 0x91, 0x7e, 0x63,
-  0xb6, 0xab, 0xa6, 0x5f, 0xc3, 0xa4, 0x84, 0xf8, 0x4f, 0x62, 0x51, 0xbe,
-  0xf8, 0xc5, 0xec, 0xdb, 0x38, 0x92, 0xe3, 0x06, 0xe5, 0x08, 0x91, 0x0c,
-  0xc4, 0x28, 0x41, 0x55, 0xfb, 0xcb, 0x5a, 0x89, 0x15, 0x7e, 0x71, 0xe8,
-  0x35, 0xbf, 0x4d, 0x72, 0x09, 0x3d, 0xbe, 0x3a, 0x38, 0x50, 0x5b, 0x77,
-  0x31, 0x1b, 0x8d, 0xb3, 0xc7, 0x24, 0x45, 0x9a, 0xa7, 0xac, 0x6d, 0x00,
-  0x14, 0x5a, 0x04, 0xb7, 0xba, 0x13, 0xeb, 0x51, 0x0a, 0x98, 0x41, 0x41,
-  0x22, 0x4e, 0x65, 0x61, 0x87, 0x81, 0x41, 0x50, 0xa6, 0x79, 0x5c, 0x89,
-  0xde, 0x19, 0x4a, 0x57, 0xd5, 0x2e, 0xe6, 0x5d, 0x1c, 0x53, 0x2c, 0x7e,
-  0x98, 0xcd, 0x1a, 0x06, 0x16, 0xa4, 0x68, 0x73, 0xd0, 0x34, 0x04, 0x13,
-  0x5c, 0xa1, 0x71, 0xd3, 0x5a, 0x7c, 0x55, 0xdb, 0x5e, 0x64, 0xe1, 0x37,
-  0x87, 0x30, 0x56, 0x04, 0xe5, 0x11, 0xb4, 0x29, 0x80, 0x12, 0xf1, 0x79,
-  0x39, 0x88, 0xa2, 0x02, 0x11, 0x7c, 0x27, 0x66, 0xb7, 0x88, 0xb7, 0x78,
-  0xf2, 0xca, 0x0a, 0xa8, 0x38, 0xab, 0x0a, 0x64, 0xc2, 0xbf, 0x66, 0x5d,
-  0x95, 0x84, 0xc1, 0xa1, 0x25, 0x1e, 0x87, 0x5d, 0x1a, 0x50, 0x0b, 0x20,
-  0x12, 0xcc, 0x41, 0xbb, 0x6e, 0x0b, 0x51, 0x38, 0xb8, 0x4b, 0xcb, 0x02,
-  0x03, 0x01, 0x00, 0x01, 0xa3, 0x63, 0x30, 0x61, 0x30, 0x0e, 0x06, 0x03,
-  0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02, 0x01, 0x86,
-  0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05,
-  0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e,
-  0x04, 0x16, 0x04, 0x14, 0xb1, 0x3e, 0xc3, 0x69, 0x03, 0xf8, 0xbf, 0x47,
-  0x01, 0xd4, 0x98, 0x26, 0x1a, 0x08, 0x02, 0xef, 0x63, 0x64, 0x2b, 0xc3,
-  0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80,
-  0x14, 0xb1, 0x3e, 0xc3, 0x69, 0x03, 0xf8, 0xbf, 0x47, 0x01, 0xd4, 0x98,
-  0x26, 0x1a, 0x08, 0x02, 0xef, 0x63, 0x64, 0x2b, 0xc3, 0x30, 0x0d, 0x06,
-  0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00,
-  0x03, 0x82, 0x01, 0x01, 0x00, 0x1c, 0x1a, 0x06, 0x97, 0xdc, 0xd7, 0x9c,
-  0x9f, 0x3c, 0x88, 0x66, 0x06, 0x08, 0x57, 0x21, 0xdb, 0x21, 0x47, 0xf8,
-  0x2a, 0x67, 0xaa, 0xbf, 0x18, 0x32, 0x76, 0x40, 0x10, 0x57, 0xc1, 0x8a,
-  0xf3, 0x7a, 0xd9, 0x11, 0x65, 0x8e, 0x35, 0xfa, 0x9e, 0xfc, 0x45, 0xb5,
-  0x9e, 0xd9, 0x4c, 0x31, 0x4b, 0xb8, 0x91, 0xe8, 0x43, 0x2c, 0x8e, 0xb3,
-  0x78, 0xce, 0xdb, 0xe3, 0x53, 0x79, 0x71, 0xd6, 0xe5, 0x21, 0x94, 0x01,
-  0xda, 0x55, 0x87, 0x9a, 0x24, 0x64, 0xf6, 0x8a, 0x66, 0xcc, 0xde, 0x9c,
-  0x37, 0xcd, 0xa8, 0x34, 0xb1, 0x69, 0x9b, 0x23, 0xc8, 0x9e, 0x78, 0x22,
-  0x2b, 0x70, 0x43, 0xe3, 0x55, 0x47, 0x31, 0x61, 0x19, 0xef, 0x58, 0xc5,
-  0x85, 0x2f, 0x4e, 0x30, 0xf6, 0xa0, 0x31, 0x16, 0x23, 0xc8, 0xe7, 0xe2,
-  0x65, 0x16, 0x33, 0xcb, 0xbf, 0x1a, 0x1b, 0xa0, 0x3d, 0xf8, 0xca, 0x5e,
-  0x8b, 0x31, 0x8b, 0x60, 0x08, 0x89, 0x2d, 0x0c, 0x06, 0x5c, 0x52, 0xb7,
-  0xc4, 0xf9, 0x0a, 0x98, 0xd1, 0x15, 0x5f, 0x9f, 0x12, 0xbe, 0x7c, 0x36,
-  0x63, 0x38, 0xbd, 0x44, 0xa4, 0x7f, 0xe4, 0x26, 0x2b, 0x0a, 0xc4, 0x97,
-  0x69, 0x0d, 0xe9, 0x8c, 0xe2, 0xc0, 0x10, 0x57, 0xb8, 0xc8, 0x76, 0x12,
-  0x91, 0x55, 0xf2, 0x48, 0x69, 0xd8, 0xbc, 0x2a, 0x02, 0x5b, 0x0f, 0x44,
-  0xd4, 0x20, 0x31, 0xdb, 0xf4, 0xba, 0x70, 0x26, 0x5d, 0x90, 0x60, 0x9e,
-  0xbc, 0x4b, 0x17, 0x09, 0x2f, 0xb4, 0xcb, 0x1e, 0x43, 0x68, 0xc9, 0x07,
-  0x27, 0xc1, 0xd2, 0x5c, 0xf7, 0xea, 0x21, 0xb9, 0x68, 0x12, 0x9c, 0x3c,
-  0x9c, 0xbf, 0x9e, 0xfc, 0x80, 0x5c, 0x9b, 0x63, 0xcd, 0xec, 0x47, 0xaa,
-  0x25, 0x27, 0x67, 0xa0, 0x37, 0xf3, 0x00, 0x82, 0x7d, 0x54, 0xd7, 0xa9,
-  0xf8, 0xe9, 0x2e, 0x13, 0xa3, 0x77, 0xe8, 0x1f, 0x4a
-};
-const unsigned int caCertLen = 969;
-
diff --git a/libraries/ESP8266WiFi/examples/HTTPSRequestCACertAxTLS/HTTPSRequestCACertAxTLS.ino b/libraries/ESP8266WiFi/examples/HTTPSRequestCACertAxTLS/HTTPSRequestCACertAxTLS.ino
deleted file mode 100644
index 2e301972b4..0000000000
--- a/libraries/ESP8266WiFi/examples/HTTPSRequestCACertAxTLS/HTTPSRequestCACertAxTLS.ino
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
-    HTTP over TLS (HTTPS) example sketch
-
-    This example demonstrates how to use
-    WiFiClientSecure class to connect to a TLS server.
-
-    This example verifies server certificate using the
-    root CA certificate.
-
-    We fetch and display the status of
-    esp8266/Arduino project continuous integration
-    build.
-
-    Created by Ivan Grokhotkov, 2017.
-    This example is in public domain.
-*/
-
-#define USING_AXTLS
-#include <time.h>
-#include <ESP8266WiFi.h>
-
-// force use of AxTLS (BearSSL is now default)
-#include <WiFiClientSecureAxTLS.h>
-using namespace axTLS;
-
-#ifndef STASSID
-#define STASSID "your-ssid"
-#define STAPSK  "your-password"
-#endif
-
-const char* ssid = STASSID;
-const char* password = STAPSK;
-
-const char* host = "api.github.com";
-const int httpsPort = 443;
-
-// Root certificate used by api.github.com.
-// Defined in "CACert" tab.
-extern const unsigned char caCert[] PROGMEM;
-extern const unsigned int caCertLen;
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored  "-Wdeprecated-declarations"
-WiFiClientSecure client;
-#pragma GCC diagnostic pop
-
-void setup() {
-  Serial.begin(115200);
-  Serial.println();
-  Serial.print("connecting to ");
-  Serial.println(ssid);
-  WiFi.mode(WIFI_STA);
-  WiFi.begin(ssid, password);
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(500);
-    Serial.print(".");
-  }
-  Serial.println("");
-  Serial.println("WiFi connected");
-  Serial.println("IP address: ");
-  Serial.println(WiFi.localIP());
-
-  // Synchronize time useing SNTP. This is necessary to verify that
-  // the TLS certificates offered by the server are currently valid.
-  Serial.print("Setting time using SNTP");
-  configTime(8 * 3600, 0, "pool.ntp.org", "time.nist.gov");
-  time_t now = time(nullptr);
-  while (now < 8 * 3600 * 2) {
-    delay(500);
-    Serial.print(".");
-    now = time(nullptr);
-  }
-  Serial.println("");
-  struct tm timeinfo;
-  gmtime_r(&now, &timeinfo);
-  Serial.print("Current time: ");
-  Serial.print(asctime(&timeinfo));
-
-  // Load root certificate in DER format into WiFiClientSecure object
-  bool res = client.setCACert_P(caCert, caCertLen);
-  if (!res) {
-    Serial.println("Failed to load root CA certificate!");
-    while (true) {
-      yield();
-    }
-  }
-}
-
-void loop() {
-  // Connect to remote server
-  Serial.print("connecting to ");
-  Serial.println(host);
-  if (!client.connect(host, httpsPort)) {
-    Serial.println("connection failed");
-    return;
-  }
-
-  // Verify validity of server's certificate
-  if (client.verifyCertChain(host)) {
-    Serial.println("Server certificate verified");
-  } else {
-    Serial.println("ERROR: certificate verification failed!");
-    return;
-  }
-
-  String url = "/repos/esp8266/Arduino/commits/master/status";
-  Serial.print("requesting URL: ");
-  Serial.println(url);
-
-  client.print(String("GET ") + url + " HTTP/1.1\r\n" +
-               "Host: " + host + "\r\n" +
-               "User-Agent: BuildFailureDetectorESP8266\r\n" +
-               "Connection: close\r\n\r\n");
-
-  Serial.println("request sent");
-  while (client.connected()) {
-    String line = client.readStringUntil('\n');
-    if (line == "\r") {
-      Serial.println("headers received");
-      break;
-    }
-  }
-  String line = client.readStringUntil('\n');
-  if (line.startsWith("{\"state\":\"success\"")) {
-    Serial.println("esp8266/Arduino CI successfull!");
-  } else {
-    Serial.println("esp8266/Arduino CI has failed");
-  }
-  Serial.println("reply was:");
-  Serial.println("==========");
-  Serial.println(line);
-  Serial.println("==========");
-  Serial.println();
-
-  static int repeat = 0;
-  if (++repeat == 3) {
-    Serial.println("Done");
-    while (true) {
-      delay(1000);
-    }
-  }
-  delay(10000);
-}
-
-
diff --git a/libraries/ESP8266WiFi/examples/WiFiHTTPSServer/WiFiHTTPSServer.ino b/libraries/ESP8266WiFi/examples/WiFiHTTPSServer/WiFiHTTPSServer.ino
deleted file mode 100644
index adb18b4122..0000000000
--- a/libraries/ESP8266WiFi/examples/WiFiHTTPSServer/WiFiHTTPSServer.ino
+++ /dev/null
@@ -1,208 +0,0 @@
-/*
-  WiFiHTTPSServer - Simple SSL server example
-
-  This sketch demonstrates how to set up a simple HTTP-like server usingcl
-  HTTPS encryption. This is NOT the recommended way of writing a web server!
-  Please see the ESP8266WebServer and ESP8266WebServerSecure for a much easier
-  and more robust server for your own applications.
-
-  The server will set a GPIO pin depending on the request
-    https://server_ip/gpio/0 will set the GPIO2 low,
-    https://server_ip/gpio/1 will set the GPIO2 high
-  server_ip is the IP address of the ESP8266 module, will be
-  printed to Serial when the module is connected.
-
-  IMPORTANT NOTES ABOUT SSL CERTIFICATES
-
-  1. USE/GENERATE YOUR OWN CERTIFICATES
-    While a sample, self-signed certificate is included in this example,
-    it is ABSOLUTELY VITAL that you use your own SSL certificate in any
-    real-world deployment.  Anyone with the certificate and key may be
-    able to decrypt your traffic, so your own keys should be kept in a
-    safe manner, not accessible on any public network.
-
-  2. HOW TO GENERATE YOUR OWN CERTIFICATE/KEY PAIR
-    A sample script, "make-self-signed-cert.sh" is provided in the
-    ESP8266WiFi/examples/WiFiHTTPSServer directory.  This script can be
-    modified (replace "your-name-here" with your Organization name).  Note
-    that this will be a *self-signed certificate* and will *NOT* be accepted
-    by default by most modern browsers.  They'll display something like,
-    "This certificate is from an untrusted source," or "Your connection is
-    not secure," or "Your connection is not private," and the user will
-    have to manully allow the browser to continue by using the
-    "Advanced/Add Exception" (FireFox) or "Advanced/Proceed" (Chrome) link.
-
-    You may also, of course, use a commercial, trusted SSL provider to
-    generate your certificate.  When requesting the certificate, you'll
-    need to specify that it use SHA256 and 1024 or 512 bits in order to
-    function with the axTLS implementation in the ESP8266.
-
-  Adapted by Earle F. Philhower, III, from the WiFiWebServer.ino example.
-  This example is released into the public domain.
-*/
-
-#include <ESP8266WiFi.h>
-
-#ifndef STASSID
-#define STASSID "your-ssid"
-#define STAPSK  "your-password"
-#endif
-
-const char* ssid = STASSID;
-const char* password = STAPSK;
-
-// The certificate is stored in PMEM
-static const uint8_t x509[] PROGMEM = {
-  0x30, 0x82, 0x01, 0x3d, 0x30, 0x81, 0xe8, 0x02, 0x09, 0x00, 0xfe, 0x56,
-  0x46, 0xf2, 0x78, 0xc6, 0x51, 0x17, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86,
-  0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x30, 0x26, 0x31,
-  0x10, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x07, 0x45, 0x53,
-  0x50, 0x38, 0x32, 0x36, 0x36, 0x31, 0x12, 0x30, 0x10, 0x06, 0x03, 0x55,
-  0x04, 0x03, 0x0c, 0x09, 0x31, 0x32, 0x37, 0x2e, 0x30, 0x2e, 0x30, 0x2e,
-  0x31, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x37, 0x30, 0x33, 0x31, 0x38, 0x31,
-  0x34, 0x34, 0x39, 0x31, 0x38, 0x5a, 0x17, 0x0d, 0x33, 0x30, 0x31, 0x31,
-  0x32, 0x35, 0x31, 0x34, 0x34, 0x39, 0x31, 0x38, 0x5a, 0x30, 0x26, 0x31,
-  0x10, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x07, 0x45, 0x53,
-  0x50, 0x38, 0x32, 0x36, 0x36, 0x31, 0x12, 0x30, 0x10, 0x06, 0x03, 0x55,
-  0x04, 0x03, 0x0c, 0x09, 0x31, 0x32, 0x37, 0x2e, 0x30, 0x2e, 0x30, 0x2e,
-  0x31, 0x30, 0x5c, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
-  0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x4b, 0x00, 0x30, 0x48, 0x02,
-  0x41, 0x00, 0xc6, 0x72, 0x6c, 0x12, 0xe1, 0x20, 0x4d, 0x10, 0x0c, 0xf7,
-  0x3a, 0x2a, 0x5a, 0x49, 0xe2, 0x2d, 0xc9, 0x7a, 0x63, 0x1d, 0xef, 0xc6,
-  0xbb, 0xa3, 0xd6, 0x6f, 0x59, 0xcb, 0xd5, 0xf6, 0xbe, 0x34, 0x83, 0x33,
-  0x50, 0x80, 0xec, 0x49, 0x63, 0xbf, 0xee, 0x59, 0x94, 0x67, 0x8b, 0x8d,
-  0x81, 0x85, 0x23, 0x24, 0x06, 0x52, 0x76, 0x55, 0x9d, 0x18, 0x09, 0xb3,
-  0x3c, 0x10, 0x40, 0x05, 0x01, 0xf3, 0x02, 0x03, 0x01, 0x00, 0x01, 0x30,
-  0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b,
-  0x05, 0x00, 0x03, 0x41, 0x00, 0x69, 0xdc, 0x6c, 0x9b, 0xa7, 0x62, 0x57,
-  0x7e, 0x03, 0x01, 0x45, 0xad, 0x9a, 0x83, 0x90, 0x3a, 0xe7, 0xdf, 0xe8,
-  0x8f, 0x46, 0x00, 0xd3, 0x5f, 0x2b, 0x0a, 0xde, 0x92, 0x1b, 0xc5, 0x04,
-  0xc5, 0xc0, 0x76, 0xf4, 0xf6, 0x08, 0x36, 0x97, 0x27, 0x82, 0xf1, 0x60,
-  0x76, 0xc2, 0xcd, 0x67, 0x6c, 0x4b, 0x6c, 0xca, 0xfd, 0x97, 0xfd, 0x33,
-  0x9e, 0x12, 0x67, 0x6b, 0x98, 0x7e, 0xd5, 0x80, 0x8f
-};
-
-// And so is the key.  These could also be in DRAM
-static const uint8_t rsakey[] PROGMEM = {
-  0x30, 0x82, 0x01, 0x3a, 0x02, 0x01, 0x00, 0x02, 0x41, 0x00, 0xc6, 0x72,
-  0x6c, 0x12, 0xe1, 0x20, 0x4d, 0x10, 0x0c, 0xf7, 0x3a, 0x2a, 0x5a, 0x49,
-  0xe2, 0x2d, 0xc9, 0x7a, 0x63, 0x1d, 0xef, 0xc6, 0xbb, 0xa3, 0xd6, 0x6f,
-  0x59, 0xcb, 0xd5, 0xf6, 0xbe, 0x34, 0x83, 0x33, 0x50, 0x80, 0xec, 0x49,
-  0x63, 0xbf, 0xee, 0x59, 0x94, 0x67, 0x8b, 0x8d, 0x81, 0x85, 0x23, 0x24,
-  0x06, 0x52, 0x76, 0x55, 0x9d, 0x18, 0x09, 0xb3, 0x3c, 0x10, 0x40, 0x05,
-  0x01, 0xf3, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x40, 0x35, 0x0b, 0x74,
-  0xd3, 0xff, 0x15, 0x51, 0x44, 0x0f, 0x13, 0x2e, 0x9b, 0x0f, 0x93, 0x5c,
-  0x3f, 0xfc, 0xf1, 0x17, 0xf9, 0x72, 0x94, 0x5e, 0xa7, 0xc6, 0xb3, 0xf0,
-  0xfe, 0xc9, 0x6c, 0xb1, 0x1e, 0x83, 0xb3, 0xc6, 0x45, 0x3a, 0x25, 0x60,
-  0x7c, 0x3d, 0x92, 0x7d, 0x53, 0xec, 0x49, 0x8d, 0xb5, 0x45, 0x10, 0x99,
-  0x9b, 0xc6, 0x22, 0x3a, 0x68, 0xc7, 0x13, 0x4e, 0xb6, 0x04, 0x61, 0x21,
-  0x01, 0x02, 0x21, 0x00, 0xea, 0x8c, 0x21, 0xd4, 0x7f, 0x3f, 0xb6, 0x91,
-  0xfa, 0xf8, 0xb9, 0x2d, 0xcb, 0x36, 0x36, 0x02, 0x5f, 0xf0, 0x0c, 0x6e,
-  0x87, 0xaa, 0x5c, 0x14, 0xf6, 0x56, 0x8e, 0x12, 0x92, 0x25, 0xde, 0xb3,
-  0x02, 0x21, 0x00, 0xd8, 0x99, 0x01, 0xf1, 0x04, 0x0b, 0x98, 0xa3, 0x71,
-  0x56, 0x1d, 0xea, 0x6f, 0x45, 0xd1, 0x36, 0x70, 0x76, 0x8b, 0xab, 0x69,
-  0x30, 0x58, 0x9c, 0xe0, 0x45, 0x97, 0xe7, 0xb6, 0xb5, 0xef, 0xc1, 0x02,
-  0x21, 0x00, 0xa2, 0x01, 0x06, 0xc0, 0xf2, 0xdf, 0xbc, 0x28, 0x1a, 0xb4,
-  0xbf, 0x9b, 0x5c, 0xd8, 0x65, 0xf7, 0xbf, 0xf2, 0x5b, 0x73, 0xe0, 0xeb,
-  0x0f, 0xcd, 0x3e, 0xd5, 0x4c, 0x2e, 0x91, 0x99, 0xec, 0xb7, 0x02, 0x20,
-  0x4b, 0x9d, 0x46, 0xd7, 0x3c, 0x01, 0x4c, 0x5d, 0x2a, 0xb0, 0xd4, 0xaa,
-  0xc6, 0x03, 0xca, 0xa0, 0xc5, 0xac, 0x2c, 0xe0, 0x3f, 0x4d, 0x98, 0x71,
-  0xd3, 0xbd, 0x97, 0xe5, 0x55, 0x9c, 0xb8, 0x41, 0x02, 0x20, 0x02, 0x42,
-  0x9f, 0xd1, 0x06, 0x35, 0x3b, 0x42, 0xf5, 0x64, 0xaf, 0x6d, 0xbf, 0xcd,
-  0x2c, 0x3a, 0xcd, 0x0a, 0x9a, 0x4d, 0x7c, 0xad, 0x29, 0xd6, 0x36, 0x57,
-  0xd5, 0xdf, 0x34, 0xeb, 0x26, 0x03
-};
-
-// Create an instance of the server
-// specify the port to listen on as an argument
-WiFiServerSecure server(443);
-
-void setup() {
-  Serial.begin(115200);
-
-  // prepare GPIO2
-  pinMode(2, OUTPUT);
-  digitalWrite(2, 0);
-
-  // Connect to WiFi network
-  Serial.println();
-  Serial.println();
-  Serial.print("Connecting to ");
-  Serial.println(ssid);
-
-  WiFi.begin(ssid, password);
-
-  while (WiFi.status() != WL_CONNECTED) {
-    delay(500);
-    Serial.print(".");
-  }
-  Serial.println("");
-  Serial.println("WiFi connected");
-
-  // Set the certificates from PMEM (if using DRAM remove the _P from the call)
-  server.setServerKeyAndCert_P(rsakey, sizeof(rsakey), x509, sizeof(x509));
-
-  // Start the server
-  server.begin();
-  Serial.println("Server started");
-
-  // Print the IP address
-  Serial.println(WiFi.localIP());
-}
-
-void loop() {
-  // Check if a client has connected
-  WiFiClientSecure client = server.available();
-  if (!client) {
-    return;
-  }
-
-  // Wait until the client sends some data
-  Serial.println("new client");
-  unsigned long timeout = millis() + 3000;
-  while (!client.available() && millis() < timeout) {
-    delay(1);
-  }
-  if (millis() > timeout) {
-    Serial.println("timeout");
-    client.flush();
-    client.stop();
-    return;
-  }
-
-  // Read the first line of the request
-  String req = client.readStringUntil('\r');
-  Serial.println(req);
-  client.flush();
-
-  // Match the request
-  int val;
-  if (req.indexOf("/gpio/0") != -1) {
-    val = 0;
-  } else if (req.indexOf("/gpio/1") != -1) {
-    val = 1;
-  } else {
-    Serial.println("invalid request");
-    client.print("HTTP/1.1 404 Not Found\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE HTML>\r\n<html><body>Not found</body></html>");
-    return;
-  }
-
-  // Set GPIO2 according to the request
-  digitalWrite(2, val);
-
-  client.flush();
-
-  // Prepare the response
-  String s = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE HTML>\r\n<html>\r\nGPIO is now ";
-  s += (val) ? "high" : "low";
-  s += "</html>\n";
-
-  // Send the response to the client
-  client.print(s);
-  delay(1);
-  Serial.println("Client disconnected");
-
-  // The client will actually be disconnected
-  // when the function returns and 'client' object is detroyed
-}
-
diff --git a/libraries/ESP8266WiFi/examples/WiFiHTTPSServer/make-self-signed-cert.sh b/libraries/ESP8266WiFi/examples/WiFiHTTPSServer/make-self-signed-cert.sh
deleted file mode 100755
index cfe42250fc..0000000000
--- a/libraries/ESP8266WiFi/examples/WiFiHTTPSServer/make-self-signed-cert.sh
+++ /dev/null
@@ -1,49 +0,0 @@
-#!/bin/bash
-
-# This script generates a self-signed certificate for use by the ESP8266
-# Replace your-name-here with somethine appropriate before running and use
-# the generated .H files in your code as follows:
-#
-#      static const uint8_t rsakey[] PROGMEM = {
-#        #include "key.h"
-#      };
-#
-#      static const uint8_t x509[] PROGMEM = {
-#        #include "x509.h"
-#      };
-#
-#      ....
-#      WiFiServerSecure server(443);
-#      server.setServerKeyAndCert_P(rsakey, sizeof(rsakey), x509, sizeof(x509));
-#      ....
-
-# 1024 or 512.  512 saves memory...
-BITS=512
-C=$PWD
-pushd /tmp
-
-openssl genrsa -out tls.ca_key.pem $BITS
-openssl genrsa -out tls.key_$BITS.pem $BITS
-openssl rsa -in tls.key_$BITS.pem -out tls.key_$BITS -outform DER
-cat > certs.conf <<EOF
-[ req ]
-distinguished_name = req_distinguished_name
-prompt = no
-
-[ req_distinguished_name ]
-O = your-name-here
-CN = 127.0.0.1
-EOF
-openssl req -out tls.ca_x509.req -key tls.ca_key.pem -new -config certs.conf 
-openssl req -out tls.x509_$BITS.req -key tls.key_$BITS.pem -new -config certs.conf 
-openssl x509 -req -in tls.ca_x509.req  -out tls.ca_x509.pem -sha256 -days 5000 -signkey tls.ca_key.pem 
-openssl x509 -req -in tls.x509_$BITS.req  -out tls.x509_$BITS.pem -sha256 -CAcreateserial -days 5000 -CA tls.ca_x509.pem -CAkey tls.ca_key.pem 
-openssl x509 -in tls.ca_x509.pem -outform DER -out tls.ca_x509.cer
-openssl x509 -in tls.x509_$BITS.pem -outform DER -out tls.x509_$BITS.cer
-
-xxd -i tls.key_$BITS       | sed 's/.*{//' | sed 's/\};//' | sed 's/unsigned.*//' > "$C/key.h"
-xxd -i tls.x509_$BITS.cer  | sed 's/.*{//' | sed 's/\};//' | sed 's/unsigned.*//' > "$C/x509.h"
-
-rm -f tls.ca_key.pem tls.key_$BITS.pem tls.key_$BITS certs.conf tls.ca_x509.req tls.x509_$BITS.req tls.ca_x509.pem tls.x509_$BITS.pem tls.srl tls.x509_$BITS.cer tls.ca_x509.cer
-
-popd
diff --git a/libraries/ESP8266WiFi/src/WiFiClientSecure.h b/libraries/ESP8266WiFi/src/WiFiClientSecure.h
index 235f7e07f2..25b5928014 100644
--- a/libraries/ESP8266WiFi/src/WiFiClientSecure.h
+++ b/libraries/ESP8266WiFi/src/WiFiClientSecure.h
@@ -20,27 +20,6 @@
 
 */
 
-//#include "WiFiClientSecureAxTLS.h"
-//using namespace axTLS;
-
-/**********************************
- * !! Now BearSSL is the default !!
- *
- * While not advised,
- * Use legacy API without updating with:
- *
-#define USING_AXTLS
-#include <ESP8266WiFi.h>
-//#include <WiFiClientSecure.h>
-#include "WiFiClientSecureAxTLS.h"
-using namespace axTLS;
- *
- *
- **********************************/
-
 #include "WiFiClientSecureBearSSL.h"
 
-#ifndef USING_AXTLS
-// do not default to BearSSL API ("using" has no "unusing" counterpart)
 using namespace BearSSL;
-#endif
diff --git a/libraries/ESP8266WiFi/src/WiFiClientSecureAxTLS.cpp b/libraries/ESP8266WiFi/src/WiFiClientSecureAxTLS.cpp
deleted file mode 100644
index 62969b8bd7..0000000000
--- a/libraries/ESP8266WiFi/src/WiFiClientSecureAxTLS.cpp
+++ /dev/null
@@ -1,512 +0,0 @@
-/*
-  WiFiClientSecure.cpp - Variant of WiFiClient with TLS support
-  Copyright (c) 2015 Ivan Grokhotkov. All rights reserved.
-  This file is part of the esp8266 core for Arduino environment.
-
-
-  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
-
-*/
-
-#define LWIP_INTERNAL
-
-#include "debug.h"
-#include "ESP8266WiFi.h"
-#include "WiFiClientSecure.h"
-#include "WiFiClient.h"
-
-#ifdef DEBUG_ESP_SSL
-#define DEBUG_SSL
-#endif
-
-#ifdef DEBUG_SSL
-#define SSL_DEBUG_OPTS (SSL_DISPLAY_STATES | SSL_DISPLAY_CERTS)
-#else
-#define SSL_DEBUG_OPTS 0
-#endif
-
-
-// Pull in required classes
-#include "include/SSLContext.h"
-#include "include/ClientContext.h"
-
-namespace axTLS {
-
-SSL_CTX* SSLContext::_ssl_client_ctx = nullptr;
-int SSLContext::_ssl_client_ctx_refcnt = 0;
-SSL_CTX* SSLContext::_ssl_svr_ctx = nullptr;
-int SSLContext::_ssl_svr_ctx_refcnt = 0;
-
-WiFiClientSecure::WiFiClientSecure()
-{
-    // TLS handshake may take more than the 5 second default timeout
-    _timeout = 15000;
-}
-
-WiFiClientSecure::~WiFiClientSecure()
-{
-   _ssl = nullptr;
-}
-
-// Only called by the WifiServerSecure, need to get the keys/certs loaded before beginning
-WiFiClientSecure::WiFiClientSecure(ClientContext* client, bool usePMEM,
-                                   const uint8_t *rsakey, int rsakeyLen,
-                                   const uint8_t *cert, int certLen)
-{
-    // TLS handshake may take more than the 5 second default timeout
-    _timeout = 15000;
-
-    // We've been given the client context from the available() call
-    _client = client;
-    _client->ref();
-
-    // Make the "_ssl" SSLContext, in the constructor there should be none yet
-    SSLContext *_new_ssl = new SSLContext(true);
-    std::shared_ptr<SSLContext> _new_ssl_shared(_new_ssl);
-    _ssl = _new_ssl_shared;
-
-    if (usePMEM) {
-        if (rsakey && rsakeyLen) {
-            _ssl->loadObject_P(SSL_OBJ_RSA_KEY, rsakey, rsakeyLen);
-        }
-        if (cert && certLen) {
-            _ssl->loadObject_P(SSL_OBJ_X509_CERT, cert, certLen);
-        }
-    } else {
-        if (rsakey && rsakeyLen) {
-            _ssl->loadObject(SSL_OBJ_RSA_KEY, rsakey, rsakeyLen);
-        }
-        if (cert && certLen) {
-            _ssl->loadObject(SSL_OBJ_X509_CERT, cert, certLen);
-        }
-    }
-    _ssl->connectServer(client, _timeout);
-}
-
-int WiFiClientSecure::connect(IPAddress ip, uint16_t port)
-{
-    if (!WiFiClient::connect(ip, port)) {
-        return 0;
-    }
-
-    return _connectSSL(nullptr);
-}
-
-int WiFiClientSecure::connect(const char* name, uint16_t port)
-{
-    IPAddress remote_addr;
-    if (!WiFi.hostByName(name, remote_addr)) {
-        return 0;
-    }
-    if (!WiFiClient::connect(remote_addr, port)) {
-        return 0;
-    }
-    return _connectSSL(name);
-}
-
-int WiFiClientSecure::connect(const String& host, uint16_t port)
-{
-    return connect(host.c_str(), port);
-}
-
-int WiFiClientSecure::_connectSSL(const char* hostName)
-{
-    if (!_ssl) {
-        _ssl = std::make_shared<SSLContext>();
-	if (!_ssl) {
-          return 0;
-        }
-    }
-    _ssl->connect(_client, hostName, _timeout);
-
-    auto status = ssl_handshake_status(*_ssl);
-    if (status != SSL_OK) {
-        _ssl = nullptr;
-        return 0;
-    }
-
-    return 1;
-}
-
-size_t WiFiClientSecure::write(const uint8_t *buf, size_t size)
-{
-    if (!_ssl) {
-        return 0;
-    }
-
-    int rc = _ssl->write(buf, size);
-    if (rc >= 0) {
-        return rc;
-    }
-
-    if (rc != SSL_CLOSE_NOTIFY) {
-        _ssl = nullptr;
-    }
-
-    return 0;
-}
-
-size_t WiFiClientSecure::write_P(PGM_P buf, size_t size)
-{
-    // Copy to RAM and call normal send. alloca() auto-frees on return
-    uint8_t *copy = (uint8_t*)alloca(size);
-    memcpy_P(copy, buf, size);
-    return write(copy, size);
-}
-
-// The axTLS bare libs don't understand anything about Arduino Streams,
-// so we have to manually read and send individual chunks.
-size_t WiFiClientSecure::write(Stream& stream)
-{
-    size_t totalSent = 0;
-    size_t countRead;
-    size_t countSent;
-    if (!_ssl) {
-        return 0;
-    }
-    do {
-        uint8_t temp[256]; // Temporary chunk size same as ClientContext
-        countSent = 0;
-        countRead = stream.readBytes(temp, sizeof(temp));
-        if (countRead) {
-            countSent = write(temp, countRead);
-            totalSent += countSent;
-        }
-        yield(); // Feed the WDT
-    } while ( (countSent == countRead) && (countSent > 0) );
-    return totalSent;
-}
-
-int WiFiClientSecure::read(uint8_t *buf, size_t size)
-{
-    if (!_ssl) {
-        return 0;
-    }
-
-    return _ssl->read(buf, size);
-}
-
-int WiFiClientSecure::read()
-{
-    if (!_ssl) {
-        return -1;
-    }
-
-    return _ssl->read();
-}
-
-int WiFiClientSecure::peek()
-{
-    if (!_ssl) {
-        return -1;
-    }
-
-    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 (!_ssl) {
-        return 0;
-    }
-
-    if (available() < (int) length) {
-        count = available();
-    } else {
-        count = length;
-    }
-
-    return _ssl->peekBytes((char *)buffer, count);
-}
-
-int WiFiClientSecure::available()
-{
-    if (!_ssl) {
-        return 0;
-    }
-
-    return _ssl->available();
-}
-
-
-/*
-SSL     TCP     RX data     connected
-null    x       x           N
-!null   x       Y           Y
-Y       Y       x           Y
-x       N       N           N
-err     x       N           N
-*/
-uint8_t WiFiClientSecure::connected()
-{
-    if (_ssl) {
-        if (_ssl->hasData()) {
-            return true;
-        }
-        if (_client && _client->state() == ESTABLISHED && _ssl->connected()) {
-            return true;
-        }
-    }
-    return false;
-}
-
-bool WiFiClientSecure::stop(unsigned int maxWaitMs)
-{
-    if (_ssl) {
-        _ssl->stop();
-    }
-    return WiFiClient::stop(maxWaitMs);
-}
-
-static bool parseHexNibble(char pb, uint8_t* res)
-{
-    if (pb >= '0' && pb <= '9') {
-        *res = (uint8_t) (pb - '0'); return true;
-    } else if (pb >= 'a' && pb <= 'f') {
-        *res = (uint8_t) (pb - 'a' + 10); return true;
-    } else if (pb >= 'A' && pb <= 'F') {
-        *res = (uint8_t) (pb - 'A' + 10); return true;
-    }
-    return false;
-}
-
-// Compare a name from certificate and domain name, return true if they match
-static bool matchName(const String& name, const String& domainName)
-{
-    int wildcardPos = name.indexOf('*');
-    if (wildcardPos == -1) {
-        // Not a wildcard, expect an exact match
-        return name == domainName;
-    }
-    int firstDotPos = name.indexOf('.');
-    if (wildcardPos > firstDotPos) {
-        // Wildcard is not part of leftmost component of domain name
-        // Do not attempt to match (rfc6125 6.4.3.1)
-        return false;
-    }
-    if (wildcardPos != 0 || firstDotPos != 1) {
-        // Matching of wildcards such as baz*.example.com and b*z.example.com
-        // is optional. Maybe implement this in the future?
-        return false;
-    }
-    int domainNameFirstDotPos = domainName.indexOf('.');
-    if (domainNameFirstDotPos < 0) {
-        return false;
-    }
-    return domainName.substring(domainNameFirstDotPos) == name.substring(firstDotPos);
-}
-
-bool WiFiClientSecure::verify(const char* fp, const char* domain_name)
-{
-    if (!_ssl) {
-        return false;
-    }
-
-    uint8_t sha1[20];
-    int len = strlen(fp);
-    int pos = 0;
-    for (size_t i = 0; i < sizeof(sha1); ++i) {
-        while (pos < len && ((fp[pos] == ' ') || (fp[pos] == ':'))) {
-            ++pos;
-        }
-        if (pos > len - 2) {
-            DEBUGV("pos:%d len:%d fingerprint too short\r\n", pos, len);
-            return false;
-        }
-        uint8_t high, low;
-        if (!parseHexNibble(fp[pos], &high) || !parseHexNibble(fp[pos+1], &low)) {
-            DEBUGV("pos:%d len:%d invalid hex sequence: %c%c\r\n", pos, len, fp[pos], fp[pos+1]);
-            return false;
-        }
-        pos += 2;
-        sha1[i] = low | (high << 4);
-    }
-    if (ssl_match_fingerprint(*_ssl, sha1) != 0) {
-        DEBUGV("fingerprint doesn't match\r\n");
-        return false;
-    }
-
-    return _verifyDN(domain_name);
-}
-
-bool WiFiClientSecure::_verifyDN(const char* domain_name)
-{
-    DEBUGV("domain name: '%s'\r\n", (domain_name)?domain_name:"(null)");
-    String domain_name_str(domain_name);
-    domain_name_str.toLowerCase();
-
-    const char* san = nullptr;
-    int i = 0;
-    while ((san = ssl_get_cert_subject_alt_dnsname(*_ssl, i)) != nullptr) {
-        String san_str(san);
-        san_str.toLowerCase();
-        if (matchName(san_str, domain_name_str)) {
-            return true;
-        }
-        DEBUGV("SAN %d: '%s', no match\r\n", i, san);
-        ++i;
-    }
-    const char* common_name = ssl_get_cert_dn(*_ssl, SSL_X509_CERT_COMMON_NAME);
-    String common_name_str(common_name);
-    common_name_str.toLowerCase();
-    if (common_name && matchName(common_name_str, domain_name_str)) {
-        return true;
-    }
-    DEBUGV("CN: '%s', no match\r\n", (common_name)?common_name:"(null)");
-
-    return false;
-}
-
-bool WiFiClientSecure::verifyCertChain(const char* domain_name)
-{
-    if (!_ssl) {
-        return false;
-    }
-    if (!_ssl->verifyCert()) {
-        return false;
-    }
-    return _verifyDN(domain_name);
-}
-
-void WiFiClientSecure::_initSSLContext()
-{
-    if (!_ssl) {
-        _ssl = std::make_shared<SSLContext>();
-    }
-}
-
-bool WiFiClientSecure::setCACert(const uint8_t* pk, size_t size)
-{
-    _initSSLContext();
-    return _ssl ? _ssl->loadObject(SSL_OBJ_X509_CACERT, pk, size) : false;
-}
-
-bool WiFiClientSecure::setCertificate(const uint8_t* pk, size_t size)
-{
-    _initSSLContext();
-    return _ssl ? _ssl->loadObject(SSL_OBJ_X509_CERT, pk, size) : false;
-}
-
-bool WiFiClientSecure::setPrivateKey(const uint8_t* pk, size_t size)
-{
-    _initSSLContext();
-    return _ssl ? _ssl->loadObject(SSL_OBJ_RSA_KEY, pk, size) : false;
-}
-
-bool WiFiClientSecure::setCACert_P(PGM_VOID_P pk, size_t size)
-{
-    _initSSLContext();
-    return _ssl ? _ssl->loadObject_P(SSL_OBJ_X509_CACERT, pk, size) : false;
-}
-
-bool WiFiClientSecure::setCertificate_P(PGM_VOID_P pk, size_t size)
-{
-    _initSSLContext();
-    return _ssl ? _ssl->loadObject_P(SSL_OBJ_X509_CERT, pk, size) : false;
-}
-
-bool WiFiClientSecure::setPrivateKey_P(PGM_VOID_P pk, size_t size)
-{
-    _initSSLContext();
-    return _ssl ? _ssl->loadObject_P(SSL_OBJ_RSA_KEY, pk, size) : false;
-}
-
-bool WiFiClientSecure::loadCACert(Stream& stream, size_t size)
-{
-    _initSSLContext();
-    return _ssl ? _ssl->loadObject(SSL_OBJ_X509_CACERT, stream, size) : false;
-}
-
-bool WiFiClientSecure::loadCertificate(Stream& stream, size_t size)
-{
-    _initSSLContext();
-    return _ssl ? _ssl->loadObject(SSL_OBJ_X509_CERT, stream, size) : false;
-}
-
-bool WiFiClientSecure::loadPrivateKey(Stream& stream, size_t size)
-{
-    _initSSLContext();
-    return _ssl ? _ssl->loadObject(SSL_OBJ_RSA_KEY, stream, size) : false;
-}
-
-void WiFiClientSecure::allowSelfSignedCerts()
-{
-    _initSSLContext();
-    if (_ssl) {
-        _ssl->allowSelfSignedCerts();
-    }
-}
-
-extern "C" int __ax_port_read(int fd, uint8_t* buffer, size_t count)
-{
-    ClientContext* _client = SSLContext::getIOContext(fd);
-    if (!_client || (_client->state() != ESTABLISHED && !_client->getSize())) {
-        errno = EIO;
-        return -1;
-    }
-    size_t cb = _client->read((char*) buffer, count);
-    if (cb != count) {
-        errno = EAGAIN;
-    }
-    if (cb == 0) {
-        optimistic_yield(100);
-        return -1;
-    }
-    return cb;
-}
-extern "C" int ax_port_read(int fd, uint8_t* buffer, size_t count) __attribute__ ((weak, alias("__ax_port_read")));
-
-extern "C" int __ax_port_write(int fd, uint8_t* buffer, size_t count)
-{
-    ClientContext* _client = SSLContext::getIOContext(fd);
-    if (!_client || _client->state() != ESTABLISHED) {
-        errno = EIO;
-        return -1;
-    }
-
-    size_t cb = _client->write(buffer, count);
-    if (cb != count) {
-        errno = EAGAIN;
-    }
-    return cb;
-}
-extern "C" int ax_port_write(int fd, uint8_t* buffer, size_t count) __attribute__ ((weak, alias("__ax_port_write")));
-
-extern "C" int __ax_get_file(const char *filename, uint8_t **buf)
-{
-    (void) filename;
-    *buf = 0;
-    return 0;
-}
-extern "C" int ax_get_file(const char *filename, uint8_t **buf) __attribute__ ((weak, alias("__ax_get_file")));
-
-extern "C" void __ax_wdt_feed()
-{
-    optimistic_yield(10000);
-}
-extern "C" void ax_wdt_feed() __attribute__ ((weak, alias("__ax_wdt_feed")));
-
-};
diff --git a/libraries/ESP8266WiFi/src/WiFiClientSecureAxTLS.h b/libraries/ESP8266WiFi/src/WiFiClientSecureAxTLS.h
deleted file mode 100644
index 9958c46203..0000000000
--- a/libraries/ESP8266WiFi/src/WiFiClientSecureAxTLS.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
-  WiFiClientSecure.h - Variant of WiFiClient with TLS support
-  Copyright (c) 2015 Ivan Grokhotkov. All rights reserved.
-  This file is part of the esp8266 core for Arduino environment.
-
-
-  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 wificlientsecure_h
-#define wificlientsecure_h
-#include "WiFiClient.h"
-#include "include/ssl.h"
-
-
-namespace axTLS {
-
-class SSLContext;
-
-class WiFiClientSecure : public WiFiClient {
-public:
-  WiFiClientSecure() __attribute__((deprecated("Upgrade to BearSSL is advised, check https://github.com/esp8266/Arduino/blob/master/libraries/ESP8266WiFi/src/WiFiClientSecure.h#L25-L99")));
-  ~WiFiClientSecure() override;
-
-  int connect(IPAddress ip, uint16_t port) override;
-  int connect(const String& host, uint16_t port) override;
-  int connect(const char* name, uint16_t port) override;
-
-  bool verify(const char* fingerprint, const char* domain_name);
-  bool verifyCertChain(const char* domain_name);
-
-  uint8_t connected() override;
-  size_t write(const uint8_t *buf, size_t size) override;
-  size_t write_P(PGM_P buf, size_t size) override;
-  size_t write(Stream& stream); // Note this is not virtual
-  int read(uint8_t *buf, size_t size) override;
-  int available() override;
-  int read() override;
-  int peek() override;
-  size_t peekBytes(uint8_t *buffer, size_t length) override;
-  void stop() override { (void)stop(0); }
-  bool stop(unsigned int maxWaitMs);
-
-  bool setCACert(const uint8_t* pk, size_t size);
-  bool setCertificate(const uint8_t* pk, size_t size);
-  bool setPrivateKey(const uint8_t* pk, size_t size);
-
-  bool setCACert_P(PGM_VOID_P pk, size_t size);
-  bool setCertificate_P(PGM_VOID_P pk, size_t size);
-  bool setPrivateKey_P(PGM_VOID_P pk, size_t size);
-
-  bool loadCACert(Stream& stream, size_t size);
-  bool loadCertificate(Stream& stream, size_t size);
-  bool loadPrivateKey(Stream& stream, size_t size);
-
-  void allowSelfSignedCerts();
-
-  template<typename TFile>
-  bool loadCertificate(TFile& file) {
-    return loadCertificate(file, file.size());
-  }
-
-  template<typename TFile>
-  bool loadPrivateKey(TFile& file) {
-    return loadPrivateKey(file, file.size());
-  }
-  
-  template<typename TFile>
-  bool loadCACert(TFile& file) {
-    return loadCACert(file, file.size());
-  }
-
-friend class WiFiServerSecure; // Needs access to custom constructor below
-protected:
-  // Only called by WiFiServerSecure
-  WiFiClientSecure(ClientContext* client, bool usePMEM, const uint8_t *rsakey, int rsakeyLen, const uint8_t *cert, int certLen);
-
-protected:
-    void _initSSLContext();
-    int _connectSSL(const char* hostName);
-    bool _verifyDN(const char* name);
-
-    std::shared_ptr<SSLContext> _ssl = nullptr;
-};
-
-};
-
-#endif //wificlientsecure_h
diff --git a/libraries/ESP8266WiFi/src/WiFiServerSecure.h b/libraries/ESP8266WiFi/src/WiFiServerSecure.h
index 5167df562d..53806afd26 100644
--- a/libraries/ESP8266WiFi/src/WiFiServerSecure.h
+++ b/libraries/ESP8266WiFi/src/WiFiServerSecure.h
@@ -19,5 +19,4 @@
 
 #include <WiFiClientSecure.h>
 
-//#include "WiFiServerSecureAxTLS.h"
 #include "WiFiServerSecureBearSSL.h"
diff --git a/libraries/ESP8266WiFi/src/WiFiServerSecureAxTLS.cpp b/libraries/ESP8266WiFi/src/WiFiServerSecureAxTLS.cpp
deleted file mode 100644
index bba0be564a..0000000000
--- a/libraries/ESP8266WiFi/src/WiFiServerSecureAxTLS.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
-  WiFiServerSecure.cpp - SSL  server for esp8266, mostly compatible
-                   with Arduino WiFi shield library
-
-  Copyright (c) 2017 Earle F. Philhower, III
-
-  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
-*/
-
-#define LWIP_INTERNAL
-
-extern "C" {
-    #include "osapi.h"
-    #include "ets_sys.h"
-}
-
-#include "debug.h"
-#include "ESP8266WiFi.h"
-#include "WiFiClient.h"
-#include "WiFiServer.h"
-#include "lwip/opt.h"
-#include "lwip/tcp.h"
-#include "lwip/inet.h"
-#include "include/ClientContext.h"
-#include "WiFiClientSecureAxTLS.h"
-#include "WiFiServerSecureAxTLS.h"
-
-
-namespace axTLS {
-
-WiFiServerSecure::WiFiServerSecure(IPAddress addr, uint16_t port) : WiFiServer(addr, port)
-{
-}
-
-WiFiServerSecure::WiFiServerSecure(uint16_t port) : WiFiServer(port)
-{
-}
-
-void WiFiServerSecure::setServerKeyAndCert(const uint8_t *key, int keyLen, const uint8_t *cert, int certLen)
-{
-    this->usePMEM = false;
-    this->rsakey = key;
-    this->rsakeyLen = keyLen;
-    this->cert = cert;
-    this->certLen = certLen;
-}
-
-void WiFiServerSecure::setServerKeyAndCert_P(const uint8_t *key, int keyLen, const uint8_t *cert, int certLen)
-{
-    this->usePMEM = true;
-    this->rsakey = key;
-    this->rsakeyLen = keyLen;
-    this->cert = cert;
-    this->certLen = certLen;
-}
-
-WiFiClientSecure WiFiServerSecure::available(uint8_t* status)
-{
-    (void) status; // Unused
-    if (_unclaimed) {
-        WiFiClientSecure result(_unclaimed, usePMEM, rsakey, rsakeyLen, cert, certLen);
-        _unclaimed = _unclaimed->next();
-        result.setNoDelay(_noDelay);
-        DEBUGV("WS:av\r\n");
-        return result;
-    }
-
-    optimistic_yield(1000);
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored  "-Wdeprecated-declarations"
-    return WiFiClientSecure();
-#pragma GCC diagnostic pop
-}
-
-};
diff --git a/libraries/ESP8266WiFi/src/WiFiServerSecureAxTLS.h b/libraries/ESP8266WiFi/src/WiFiServerSecureAxTLS.h
deleted file mode 100644
index 777f7ac081..0000000000
--- a/libraries/ESP8266WiFi/src/WiFiServerSecureAxTLS.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
-  WiFiServerSecure.h - Library for Arduino ESP8266
-  Copyright (c) 2017 Earle F. Philhower, III
-
-  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 wifiserversecure_h
-#define wifiserversecure_h
-
-#include "WiFiServer.h"
-
-namespace axTLS {
-
-class WiFiClientSecure;
-
-class WiFiServerSecure : public WiFiServer {
-public:
-  WiFiServerSecure(IPAddress addr, uint16_t port);
-  WiFiServerSecure(uint16_t port);
-  void setServerKeyAndCert(const uint8_t *key, int keyLen, const uint8_t *cert, int certLen);
-  void setServerKeyAndCert_P(const uint8_t *key, int keyLen, const uint8_t *cert, int certLen);
-  virtual ~WiFiServerSecure() {}
-  WiFiClientSecure available(uint8_t* status = NULL);
-  using ClientType = WiFiClientSecure;
-
-private:
-  bool usePMEM = false;
-  const uint8_t *rsakey = nullptr;
-  int rsakeyLen = 0;
-  const uint8_t *cert = nullptr;
-  int certLen = 0;
-};
-
-};
-
-#endif
-
diff --git a/libraries/ESP8266WiFi/src/include/SSLContext.h b/libraries/ESP8266WiFi/src/include/SSLContext.h
deleted file mode 100644
index f7d824fbf9..0000000000
--- a/libraries/ESP8266WiFi/src/include/SSLContext.h
+++ /dev/null
@@ -1,441 +0,0 @@
-/*
-  SSLContext.h - Used by WiFiClientAxTLS
-  Copyright (c) 2015 Ivan Grokhotkov. All rights reserved.
-  This file is part of the esp8266 core for Arduino environment.
-
-
-  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 SSLCONTEXT_H
-#define SSLCONTEXT_H
-
-#define LWIP_INTERNAL
-
-extern "C"
-{
-#include "osapi.h"
-#include "ets_sys.h"
-}
-#include <list>
-#include <errno.h>
-#include "lwip/opt.h"
-#include "lwip/ip.h"
-#include "lwip/tcp.h"
-#include "lwip/inet.h"
-#include "lwip/netif.h"
-#include <include/ClientContext.h>
-#include <WiFiClientSecureAxTLS.h>
-#include "c_types.h"
-
-namespace axTLS {
-
-typedef struct BufferItem
-{
-    BufferItem(const uint8_t* data_, size_t size_)
-    : size(size_), data(new uint8_t[size])
-    {
-        if (data.get() != nullptr) {
-            memcpy(data.get(), data_, size);
-        } else {
-            DEBUGV(":wcs alloc %d failed\r\n", size_);
-            size = 0;
-        }
-    }
-
-    size_t size;
-    std::unique_ptr<uint8_t[]> data;
-} BufferItem;
-
-typedef std::list<BufferItem> BufferList;
-
-class SSLContext
-{
-public:
-    SSLContext(bool isServer = false)
-    {
-        _isServer = isServer;
-        if (!_isServer) {
-            if (_ssl_client_ctx_refcnt == 0) {
-                _ssl_client_ctx = ssl_ctx_new(SSL_SERVER_VERIFY_LATER | SSL_DEBUG_OPTS | SSL_CONNECT_IN_PARTS | SSL_READ_BLOCKING | SSL_NO_DEFAULT_KEY, 0);
-            }
-            ++_ssl_client_ctx_refcnt;
-        } else {
-            if (_ssl_svr_ctx_refcnt == 0) {
-                _ssl_svr_ctx = ssl_ctx_new(SSL_SERVER_VERIFY_LATER | SSL_DEBUG_OPTS | SSL_CONNECT_IN_PARTS | SSL_READ_BLOCKING | SSL_NO_DEFAULT_KEY, 0);
-            }
-            ++_ssl_svr_ctx_refcnt;
-        }
-    }
-
-    ~SSLContext()
-    {
-        if (io_ctx) {
-            io_ctx->unref();
-            io_ctx = nullptr;
-        }
-        _ssl = nullptr;
-        if (!_isServer) {
-            --_ssl_client_ctx_refcnt;
-            if (_ssl_client_ctx_refcnt == 0) {
-                ssl_ctx_free(_ssl_client_ctx);
-                _ssl_client_ctx = nullptr;
-            }
-        } else {
-            --_ssl_svr_ctx_refcnt;
-            if (_ssl_svr_ctx_refcnt == 0) {
-                ssl_ctx_free(_ssl_svr_ctx);
-                _ssl_svr_ctx = nullptr;
-            }
-        }
-    }
-
-    static void _delete_shared_SSL(SSL *_to_del)
-    {
-        ssl_free(_to_del);
-    }
-
-    void connect(ClientContext* ctx, const char* hostName, uint32_t timeout_ms)
-    {
-        SSL_EXTENSIONS* ext = ssl_ext_new();
-        ssl_ext_set_host_name(ext, hostName);
-        if (_ssl) {
-            /* Creating a new TLS session on top of a new TCP connection.
-               ssl_free will want to send a close notify alert, but the old TCP connection
-               is already gone at this point, so reset io_ctx. */
-            io_ctx = nullptr;
-            _ssl = nullptr;
-            _available = 0;
-            _read_ptr = nullptr;
-        }
-        io_ctx = ctx;
-        ctx->ref();
-
-        // Wrap the new SSL with a smart pointer, custom deleter to call ssl_free
-        SSL *_new_ssl = ssl_client_new(_ssl_client_ctx, reinterpret_cast<int>(this), nullptr, 0, ext);
-        std::shared_ptr<SSL> _new_ssl_shared(_new_ssl, _delete_shared_SSL);
-        _ssl = _new_ssl_shared;
-
-        uint32_t t = millis();
-
-        while (millis() - t < timeout_ms && ssl_handshake_status(_ssl.get()) != SSL_OK) {
-            uint8_t* data;
-            int rc = ssl_read(_ssl.get(), &data);
-            if (rc < SSL_OK) {
-                ssl_display_error(rc);
-                break;
-            }
-        }
-    }
-
-    void connectServer(ClientContext *ctx, uint32_t timeout_ms)
-    {
-        io_ctx = ctx;
-        ctx->ref();
-
-        // Wrap the new SSL with a smart pointer, custom deleter to call ssl_free
-	SSL *_new_ssl = ssl_server_new(_ssl_svr_ctx, reinterpret_cast<int>(this));
-        std::shared_ptr<SSL> _new_ssl_shared(_new_ssl, _delete_shared_SSL);
-        _ssl = _new_ssl_shared;
-
-        uint32_t t = millis();
-
-        while (millis() - t < timeout_ms && ssl_handshake_status(_ssl.get()) != SSL_OK) {
-            uint8_t* data;
-            int rc = ssl_read(_ssl.get(), &data);
-            if (rc < SSL_OK) {
-                ssl_display_error(rc);
-                break;
-            }
-        }
-    }
-
-    void stop()
-    {
-        if (io_ctx) {
-            io_ctx->unref();
-        }
-        io_ctx = nullptr;
-    }
-
-    bool connected()
-    {
-        if (_isServer) {
-            return _ssl != nullptr;
-        } else {
-            return _ssl != nullptr && ssl_handshake_status(_ssl.get()) == SSL_OK;
-        }
-    }
-
-    int read(uint8_t* dst, size_t size)
-    {
-        if (!_available) {
-            if (!_readAll()) {
-                return 0;
-            }
-        }
-        size_t will_copy = (_available < size) ? _available : size;
-        memcpy(dst, _read_ptr, will_copy);
-        _read_ptr += will_copy;
-        _available -= will_copy;
-        if (_available == 0) {
-            _read_ptr = nullptr;
-            /* Send pending outgoing data, if any */
-            if (_hasWriteBuffers()) {
-                _writeBuffersSend();
-            }
-        }
-        return will_copy;
-    }
-
-    int read()
-    {
-        if (!_available) {
-            if (!_readAll()) {
-                return -1;
-            }
-        }
-        int result = _read_ptr[0];
-        ++_read_ptr;
-        --_available;
-        if (_available == 0) {
-            _read_ptr = nullptr;
-            /* Send pending outgoing data, if any */
-            if (_hasWriteBuffers()) {
-                _writeBuffersSend();
-            }
-        }
-        return result;
-    }
-
-    int write(const uint8_t* src, size_t size)
-    {
-        if (_isServer) {
-            return _write(src, size);
-        } else if (!_available) {
-            if (_hasWriteBuffers()) {
-                int rc = _writeBuffersSend();
-                if (rc < 0) {
-                    return rc;
-                }
-            }
-            return _write(src, size);
-        }
-        /* Some received data is still present in the axtls fragment buffer.
-           We can't call ssl_write now, as that will overwrite the contents of
-           the fragment buffer, corrupting the received data.
-           Save a copy of the outgoing data, and call ssl_write when all
-           recevied data has been consumed by the application.
-        */
-        return _writeBufferAdd(src, size);
-    }
-
-    int peek()
-    {
-        if (!_available) {
-            if (!_readAll()) {
-                return -1;
-            }
-        }
-        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) {
-            cb = _readAll();
-        } else {
-            optimistic_yield(100);
-        }
-        return cb;
-    }
-
-    // similar to available, but doesn't return exact size
-    bool hasData()
-    {
-        return _available > 0 || (io_ctx && io_ctx->getSize() > 0);
-    }
-
-    bool loadObject(int type, Stream& stream, size_t size)
-    {
-        std::unique_ptr<uint8_t[]> buf(new uint8_t[size]);
-        if (!buf.get()) {
-            DEBUGV("loadObject: failed to allocate memory\n");
-            return false;
-        }
-
-        size_t cb = stream.readBytes(buf.get(), size);
-        if (cb != size) {
-            DEBUGV("loadObject: reading %u bytes, got %u\n", size, cb);
-            return false;
-        }
-
-        return loadObject(type, buf.get(), size);
-    }
-
-    bool loadObject_P(int type, PGM_VOID_P data, size_t size)
-    {
-        std::unique_ptr<uint8_t[]> buf(new uint8_t[size]);
-        memcpy_P(buf.get(),data, size);
-        return loadObject(type, buf.get(), size);
-    }
-
-    bool loadObject(int type, const uint8_t* data, size_t size)
-    {
-        int rc = ssl_obj_memory_load(_isServer?_ssl_svr_ctx:_ssl_client_ctx, type, data, static_cast<int>(size), nullptr);
-        if (rc != SSL_OK) {
-            DEBUGV("loadObject: ssl_obj_memory_load returned %d\n", rc);
-            return false;
-        }
-        return true;
-    }
-
-    bool verifyCert()
-    {
-        int rc = ssl_verify_cert(_ssl.get());
-        if (_allowSelfSignedCerts && rc == SSL_X509_ERROR(X509_VFY_ERROR_SELF_SIGNED)) {
-            DEBUGV("Allowing self-signed certificate\n");
-            return true;
-        } else if (rc != SSL_OK) {
-            DEBUGV("ssl_verify_cert returned %d\n", rc);
-            ssl_display_error(rc);
-            return false;
-        }
-        return true;
-    }
-
-    void allowSelfSignedCerts()
-    {
-        _allowSelfSignedCerts = true;
-    }
-
-    operator SSL*()
-    {
-        return _ssl.get();
-    }
-
-    static ClientContext* getIOContext(int fd)
-    {
-        if (fd) {
-            SSLContext *thisSSL = reinterpret_cast<SSLContext*>(fd);
-            return thisSSL->io_ctx;
-        }
-        return nullptr;
-    }
-
-protected:
-    int _readAll()
-    {
-        if (!_ssl) {
-            return 0;
-        }
-
-        optimistic_yield(100);
-
-        uint8_t* data;
-        int rc = ssl_read(_ssl.get(), &data);
-        if (rc <= 0) {
-            if (rc < SSL_OK && rc != SSL_CLOSE_NOTIFY && rc != SSL_ERROR_CONN_LOST) {
-                _ssl = nullptr;
-            }
-            return 0;
-        }
-        DEBUGV(":wcs ra %d\r\n", rc);
-        _read_ptr = data;
-        _available = rc;
-        return _available;
-    }
-
-    int _write(const uint8_t* src, size_t size)
-    {
-        if (!_ssl) {
-            return 0;
-        }
-
-        int rc = ssl_write(_ssl.get(), src, size);
-        if (rc >= 0) {
-            return rc;
-        }
-        DEBUGV(":wcs write rc=%d\r\n", rc);
-        return rc;
-    }
-
-    int _writeBufferAdd(const uint8_t* data, size_t size)
-    {
-        if (!_ssl) {
-            return 0;
-        }
-
-        _writeBuffers.emplace_back(data, size);
-        if (_writeBuffers.back().data.get() == nullptr) {
-            _writeBuffers.pop_back();
-            return 0;
-        }
-        return size;
-    }
-
-    int _writeBuffersSend()
-    {
-        while (!_writeBuffers.empty()) {
-            auto& first = _writeBuffers.front();
-            int rc = _write(first.data.get(), first.size);
-            _writeBuffers.pop_front();
-            if (rc < 0) {
-                if (_hasWriteBuffers()) {
-                    DEBUGV(":wcs _writeBuffersSend dropping unsent data\r\n");
-                    _writeBuffers.clear();
-                }
-                return rc;
-            }
-        }
-        return 0;
-    }
-
-    bool _hasWriteBuffers()
-    {
-        return !_writeBuffers.empty();
-    }
-
-    bool _isServer = false;
-    static SSL_CTX* _ssl_client_ctx;
-    static int _ssl_client_ctx_refcnt;
-    static SSL_CTX* _ssl_svr_ctx;
-    static int _ssl_svr_ctx_refcnt;
-    std::shared_ptr<SSL> _ssl = nullptr;
-    const uint8_t* _read_ptr = nullptr;
-    size_t _available = 0;
-    BufferList _writeBuffers;
-    bool _allowSelfSignedCerts = false;
-    ClientContext* io_ctx = nullptr;
-};
-
-}; // End namespace axTLS
-
-#endif
diff --git a/libraries/ESP8266WiFi/src/include/ssl.h b/libraries/ESP8266WiFi/src/include/ssl.h
deleted file mode 100644
index 8879e4cb9a..0000000000
--- a/libraries/ESP8266WiFi/src/include/ssl.h
+++ /dev/null
@@ -1,583 +0,0 @@
-/*
- * Copyright (c) 2007-2016, Cameron Rich
- *
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * * Redistributions of source code must retain the above copyright notice,
- *   this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright notice,
- *   this list of conditions and the following disclaimer in the documentation
- *   and/or other materials provided with the distribution.
- * * Neither the name of the axTLS project nor the names of its contributors
- *   may be used to endorse or promote products derived from this software
- *   without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/**
- * @mainpage axTLS API
- *
- * @image html axolotl.jpg
- *
- * The axTLS library has features such as:
- * - The TLSv1 SSL client/server protocol
- * - No requirement to use any openssl libraries.
- * - A choice between AES block (128/256 bit) and RC4 (128 bit) stream ciphers.
- * - RSA encryption/decryption with variable sized keys (up to 4096 bits).
- * - Certificate chaining and peer authentication.
- * - Session resumption, session renegotiation.
- * - ASN.1, X.509, PKCS#8, PKCS#12 keys/certificates with DER/PEM encoding.
- * - Highly configurable compile time options.
- * - Portable across many platforms (written in ANSI C), and has language
- * bindings in C, C#, VB.NET, Java, Perl and Lua.
- * - Partial openssl API compatibility (via a wrapper).
- * - A very small footprint (around 50-60kB for the library in 'server-only'
- *   mode).
- * - No dependencies on sockets - can use serial connections for example.
- * - A very simple API - ~ 20 functions/methods.
- *
- * A list of these functions/methods are described below.
- *
- *  @ref c_api
- *
- *  @ref bigint_api
- *
- *  @ref csharp_api
- *
- *  @ref java_api
- */
-#ifndef HEADER_SSL_H
-#define HEADER_SSL_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* need to predefine before ssl_lib.h gets to it */
-#define SSL_SESSION_ID_SIZE                     32
-
-#define EXP_FUNC
-#define STDCALL
-// struct SSL_CTX_;
-typedef struct SSL_CTX_ SSL_CTX;
-typedef struct SSL_ SSL;
-typedef struct SSL_EXTENSIONS_ SSL_EXTENSIONS;
-
-/* The optional parameters that can be given to the client/server SSL engine */
-#define SSL_CLIENT_AUTHENTICATION               0x00010000
-#define SSL_SERVER_VERIFY_LATER                 0x00020000
-#define SSL_NO_DEFAULT_KEY                      0x00040000
-#define SSL_DISPLAY_STATES                      0x00080000
-#define SSL_DISPLAY_BYTES                       0x00100000
-#define SSL_DISPLAY_CERTS                       0x00200000
-#define SSL_DISPLAY_RSA                         0x00400000
-#define SSL_CONNECT_IN_PARTS                    0x00800000
-#define SSL_READ_BLOCKING                       0x01000000
-
-/* errors that can be generated */
-#define SSL_OK                                  0
-#define SSL_NOT_OK                              -1
-#define SSL_ERROR_DEAD                          -2
-#define SSL_CLOSE_NOTIFY                        -3
-#define SSL_ERROR_CONN_LOST                     -256
-#define SSL_ERROR_RECORD_OVERFLOW               -257
-#define SSL_ERROR_SOCK_SETUP_FAILURE            -258
-#define SSL_ERROR_INVALID_HANDSHAKE             -260
-#define SSL_ERROR_INVALID_PROT_MSG              -261
-#define SSL_ERROR_INVALID_HMAC                  -262
-#define SSL_ERROR_INVALID_VERSION               -263
-#define SSL_ERROR_UNSUPPORTED_EXTENSION         -264
-#define SSL_ERROR_INVALID_SESSION               -265
-#define SSL_ERROR_NO_CIPHER                     -266
-#define SSL_ERROR_INVALID_CERT_HASH_ALG         -267
-#define SSL_ERROR_BAD_CERTIFICATE               -268
-#define SSL_ERROR_INVALID_KEY                   -269
-#define SSL_ERROR_FINISHED_INVALID              -271
-#define SSL_ERROR_NO_CERT_DEFINED               -272
-#define SSL_ERROR_NO_CLIENT_RENOG               -273
-#define SSL_ERROR_NOT_SUPPORTED                 -274
-#define SSL_X509_OFFSET                         -512
-#define SSL_X509_ERROR(A)                       (SSL_X509_OFFSET+A)
-
-#define X509_OK                             0
-#define X509_NOT_OK                         -1
-#define X509_VFY_ERROR_NO_TRUSTED_CERT      -2
-#define X509_VFY_ERROR_BAD_SIGNATURE        -3
-#define X509_VFY_ERROR_NOT_YET_VALID        -4
-#define X509_VFY_ERROR_EXPIRED              -5
-#define X509_VFY_ERROR_SELF_SIGNED          -6
-#define X509_VFY_ERROR_INVALID_CHAIN        -7
-#define X509_VFY_ERROR_UNSUPPORTED_DIGEST   -8
-#define X509_INVALID_PRIV_KEY               -9
-#define X509_MAX_CERTS                      -10
-#define X509_VFY_ERROR_BASIC_CONSTRAINT     -11
-
-/* alert types that are recognized */
-#define SSL_ALERT_TYPE_WARNING                  1
-#define SLL_ALERT_TYPE_FATAL                    2
-
-/* these are all the alerts that are recognized */
-#define SSL_ALERT_CLOSE_NOTIFY                  0
-#define SSL_ALERT_UNEXPECTED_MESSAGE            10
-#define SSL_ALERT_BAD_RECORD_MAC                20
-#define SSL_ALERT_RECORD_OVERFLOW               22
-#define SSL_ALERT_HANDSHAKE_FAILURE             40
-#define SSL_ALERT_BAD_CERTIFICATE               42
-#define SSL_ALERT_UNSUPPORTED_CERTIFICATE       43
-#define SSL_ALERT_CERTIFICATE_EXPIRED           45
-#define SSL_ALERT_CERTIFICATE_UNKNOWN           46
-#define SSL_ALERT_ILLEGAL_PARAMETER             47
-#define SSL_ALERT_UNKNOWN_CA                    48
-#define SSL_ALERT_DECODE_ERROR                  50
-#define SSL_ALERT_DECRYPT_ERROR                 51
-#define SSL_ALERT_INVALID_VERSION               70
-#define SSL_ALERT_NO_RENEGOTIATION              100
-#define SSL_ALERT_UNSUPPORTED_EXTENSION         110
-
-/* The ciphers that are supported */
-#define SSL_AES128_SHA                          0x2f
-#define SSL_AES256_SHA                          0x35
-#define SSL_AES128_SHA256                       0x3c
-#define SSL_AES256_SHA256                       0x3d
-
-/* build mode ids' */
-#define SSL_BUILD_SKELETON_MODE                 0x01
-#define SSL_BUILD_SERVER_ONLY                   0x02
-#define SSL_BUILD_ENABLE_VERIFICATION           0x03
-#define SSL_BUILD_ENABLE_CLIENT                 0x04
-#define SSL_BUILD_FULL_MODE                     0x05
-
-/* offsets to retrieve configuration information */
-#define SSL_BUILD_MODE                          0
-#define SSL_MAX_CERT_CFG_OFFSET                 1
-#define SSL_MAX_CA_CERT_CFG_OFFSET              2
-#define SSL_HAS_PEM                             3
-
-/* default session sizes */
-#define SSL_DEFAULT_SVR_SESS                    5
-#define SSL_DEFAULT_CLNT_SESS                   1
-
-/* X.509/X.520 distinguished name types */
-#define SSL_X509_CERT_COMMON_NAME               0
-#define SSL_X509_CERT_ORGANIZATION              1
-#define SSL_X509_CERT_ORGANIZATIONAL_NAME       2
-#define SSL_X509_CA_CERT_COMMON_NAME            3
-#define SSL_X509_CA_CERT_ORGANIZATION           4
-#define SSL_X509_CA_CERT_ORGANIZATIONAL_NAME    5
-
-/* SSL object loader types */
-#define SSL_OBJ_X509_CERT                       1
-#define SSL_OBJ_X509_CACERT                     2
-#define SSL_OBJ_RSA_KEY                         3
-#define SSL_OBJ_PKCS8                           4
-#define SSL_OBJ_PKCS12                          5
-
-/**
- * @defgroup c_api Standard C API
- * @brief The standard interface in C.
- * @{
- */
-
-/**
- * @brief Establish a new client/server context.
- *
- * This function is called before any client/server SSL connections are made.
- *
- * Each new connection will use the this context's private key and
- * certificate chain. If a different certificate chain is required, then a
- * different context needs to be be used.
- *
- * There are two threading models supported - a single thread with one
- * SSL_CTX can support any number of SSL connections - and multiple threads can
- * support one SSL_CTX object each (the default). But if a single SSL_CTX
- * object uses many SSL objects in individual threads, then the
- * CONFIG_SSL_CTX_MUTEXING option needs to be configured.
- *
- * @param options [in]  Any particular options. At present the options
- * supported are:
- * - SSL_SERVER_VERIFY_LATER (client only): Don't stop a handshake if the server
- * authentication fails. The certificate can be authenticated later with a
- * call to ssl_verify_cert().
- * - SSL_CLIENT_AUTHENTICATION (server only): Enforce client authentication
- * i.e. each handshake will include a "certificate request" message from the
- * server. Only available if verification has been enabled.
- * - SSL_DISPLAY_BYTES (full mode build only): Display the byte sequences
- * during the handshake.
- * - SSL_DISPLAY_STATES (full mode build only): Display the state changes
- * during the handshake.
- * - SSL_DISPLAY_CERTS (full mode build only): Display the certificates that
- * are passed during a handshake.
- * - SSL_DISPLAY_RSA (full mode build only): Display the RSA key details that
- * are passed during a handshake.
- * - SSL_CONNECT_IN_PARTS (client only): To use a non-blocking version of
- * ssl_client_new().
- * @param num_sessions [in] The number of sessions to be used for session
- * caching. If this value is 0, then there is no session caching. This option
- * is not used in skeleton mode.
- * @return A client/server context.
- */
-EXP_FUNC SSL_CTX * STDCALL ssl_ctx_new(uint32_t options, int num_sessions);
-
-/**
- * @brief Remove a client/server context.
- *
- * Frees any used resources used by this context. Each connection will be
- * sent a "Close Notify" alert (if possible).
- * @param ssl_ctx [in] The client/server context.
- */
-EXP_FUNC void STDCALL ssl_ctx_free(SSL_CTX *ssl_ctx);
-
-/**
- * @brief Allocates new SSL extensions structure and returns pointer to it
- *
- * @return ssl_ext Pointer to SSL_EXTENSIONS structure
- *
- */
-EXP_FUNC SSL_EXTENSIONS * STDCALL ssl_ext_new();
-
-/**
- * @brief Set the host name for SNI extension
- * @param ssl_ext pointer returned by ssl_ext_new
- * @param host_name pointer to a zero-terminated string containing host name
- */
-EXP_FUNC void STDCALL ssl_ext_set_host_name(SSL_EXTENSIONS * ext, const char* host_name);
-
-/**
- * @brief Set the maximum fragment size for the fragment size negotiation extension
- * @param ssl_ext pointer returned by ssl_ext_new
- * @param fragment_size fragment size, allowed values: 2^9, 2^10 ... 2^14
- */
-EXP_FUNC void STDCALL ssl_ext_set_max_fragment_size(SSL_EXTENSIONS * ext, unsigned fragment_size);
-
-/**
- * @brief Frees SSL extensions structure
- *
- * @param ssl_ext [in] Pointer to SSL_EXTENSION structure
- *
- */
-EXP_FUNC void STDCALL ssl_ext_free(SSL_EXTENSIONS *ssl_ext);
-
-/**
- * @brief (server only) Establish a new SSL connection to an SSL client.
- *
- * It is up to the application to establish the logical connection (whether it
- * is  a socket, serial connection etc).
- * @param ssl_ctx [in] The server context.
- * @param client_fd [in] The client's file descriptor.
- * @return An SSL object reference.
- */
-EXP_FUNC SSL * STDCALL ssl_server_new(SSL_CTX *ssl_ctx, int client_fd);
-
-/**
- * @brief (client only) Establish a new SSL connection to an SSL server.
- *
- * It is up to the application to establish the initial logical connection
- * (whether it is  a socket, serial connection etc).
- *
- * This is a normally a blocking call - it will finish when the handshake is
- * complete (or has failed). To use in non-blocking mode, set
- * SSL_CONNECT_IN_PARTS in ssl_ctx_new().
- * @param ssl_ctx [in] The client context.
- * @param client_fd [in] The client's file descriptor.
- * @param session_id [in] A 32 byte session id for session resumption. This
- * can be null if no session resumption is being used or required. This option
- * is not used in skeleton mode.
- * @param sess_id_size The size of the session id (max 32)
- * @param ssl_ext pointer to a structure with the activated SSL extensions and their values
- * @return An SSL object reference. Use ssl_handshake_status() to check
- * if a handshake succeeded.
- */
-EXP_FUNC SSL * STDCALL ssl_client_new(SSL_CTX *ssl_ctx, int client_fd, const uint8_t *session_id, uint8_t sess_id_size, SSL_EXTENSIONS* ssl_ext);
-
-/**
- * @brief Free any used resources on this connection.
-
- * A "Close Notify" message is sent on this connection (if possible). It is up
- * to the application to close the socket or file descriptor.
- * @param ssl [in] The ssl object reference.
- */
-EXP_FUNC void STDCALL ssl_free(SSL *ssl);
-
-/**
- * @brief Read the SSL data stream.
- * If the socket is non-blocking and data is blocked then SSO_OK will be
- * returned.
- * @param ssl [in] An SSL object reference.
- * @param in_data [out] If the read was successful, a pointer to the read
- * buffer will be here. Do NOT ever free this memory as this buffer is used in
- * sucessive calls. If the call was unsuccessful, this value will be null.
- * @return The number of decrypted bytes:
- * - if > 0, then the handshaking is complete and we are returning the number
- *   of decrypted bytes.
- * - SSL_OK if the handshaking stage is successful (but not yet complete).
- * - < 0 if an error.
- * @see ssl.h for the error code list.
- * @note Use in_data before doing any successive ssl calls.
- */
-EXP_FUNC int STDCALL ssl_read(SSL *ssl, uint8_t **in_data);
-
-/**
- * @brief Write to the SSL data stream.
- * if the socket is non-blocking and data is blocked then a check is made
- * to ensure that all data is sent (i.e. blocked mode is forced).
- * @param ssl [in] An SSL obect reference.
- * @param out_data [in] The data to be written
- * @param out_len [in] The number of bytes to be written.
- * @return The number of bytes sent, or if < 0 if an error.
- * @see ssl.h for the error code list.
- */
-EXP_FUNC int STDCALL ssl_write(SSL *ssl, const uint8_t *out_data, int out_len);
-
-/**
- * @brief Calculate the size of the encrypted data from what you are about to send 
- * @param ssl [in] An SSL obect reference.
- * @param out_len [in] The number of bytes to be written.
- * @return The number of bytes that will be sent, or if < 0 if an error.
- * @see ssl.h for the error code list.
- */
-EXP_FUNC int STDCALL ssl_calculate_write_length(SSL *ssl, int out_len);
-
-/**
- * @brief Find an ssl object based on a file descriptor.
- *
- * Goes through the list of SSL objects maintained in a client/server context
- * to look for a file descriptor match.
- * @param ssl_ctx [in] The client/server context.
- * @param client_fd [in]  The file descriptor.
- * @return A reference to the SSL object. Returns null if the object could not
- * be found.
- */
-EXP_FUNC SSL * STDCALL ssl_find(SSL_CTX *ssl_ctx, int client_fd);
-
-/**
- * @brief Get the session id for a handshake.
- *
- * This will be a 32 byte sequence and is available after the first
- * handshaking messages are sent.
- * @param ssl [in] An SSL object reference.
- * @return The session id as a 32 byte sequence.
- * @note A SSLv23 handshake may have only 16 valid bytes.
- */
-EXP_FUNC const uint8_t * STDCALL ssl_get_session_id(const SSL *ssl);
-
-/**
- * @brief Get the session id size for a handshake.
- *
- * This will normally be 32 but could be 0 (no session id) or something else.
- * @param ssl [in] An SSL object reference.
- * @return The size of the session id.
- */
-EXP_FUNC uint8_t STDCALL ssl_get_session_id_size(const SSL *ssl);
-
-/**
- * @brief Return the cipher id (in the SSL form).
- * @param ssl [in] An SSL object reference.
- * @return The cipher id. This will be one of the following:
- * - SSL_AES128_SHA (0x2f)
- * - SSL_AES256_SHA (0x35)
- * - SSL_RC4_128_SHA (0x05)
- * - SSL_RC4_128_MD5 (0x04)
- */
-EXP_FUNC uint8_t STDCALL ssl_get_cipher_id(const SSL *ssl);
-
-/**
- * @brief Return the status of the handshake.
- * @param ssl [in] An SSL object reference.
- * @return SSL_OK if the handshake is complete and ok.
- * @see ssl.h for the error code list.
- */
-EXP_FUNC int STDCALL ssl_handshake_status(const SSL *ssl);
-
-/**
- * @brief Retrieve various parameters about the axTLS engine.
- * @param offset [in] The configuration offset. It will be one of the following:
- * - SSL_BUILD_MODE The build mode. This will be one of the following:
- *   - SSL_BUILD_SERVER_ONLY            (basic server mode)
- *   - SSL_BUILD_ENABLE_VERIFICATION    (server can do client authentication)
- *   - SSL_BUILD_ENABLE_CLIENT          (client/server capabilties)
- *   - SSL_BUILD_FULL_MODE              (client/server with diagnostics)
- *   - SSL_BUILD_SKELETON_MODE          (skeleton mode)
- * - SSL_MAX_CERT_CFG_OFFSET The maximum number of certificates allowed.
- * - SSL_MAX_CA_CERT_CFG_OFFSET The maximum number of CA certificates allowed.
- * - SSL_HAS_PEM                        1 if supported
- * @return The value of the requested parameter.
- */
-EXP_FUNC int STDCALL ssl_get_config(int offset);
-
-/**
- * @brief Display why the handshake failed.
- *
- * This call is only useful in a 'full mode' build. The output is to stdout.
- * @param error_code [in] An error code.
- * @see ssl.h for the error code list.
- */
-EXP_FUNC void STDCALL ssl_display_error(int error_code);
-
-/**
- * @brief Authenticate a received certificate.
- *
- * This call is usually made by a client after a handshake is complete and the
- * context is in SSL_SERVER_VERIFY_LATER mode.
- * @param ssl [in] An SSL object reference.
- * @return SSL_OK if the certificate is verified.
- */
-EXP_FUNC int STDCALL ssl_verify_cert(const SSL *ssl);
-
-/**
- * @brief Check if certificate fingerprint (SHA1) matches the one given.
- *
- * @param ssl [in] An SSL object reference.
- * @param fp [in] SHA1 fingerprint to match against
- * @return SSL_OK if the certificate is verified.
- */
-EXP_FUNC int STDCALL ssl_match_fingerprint(const SSL *ssl, const uint8_t* fp);
-
-/**
- * @brief Check if SHA256 hash of Subject Public Key Info matches the one given.
- *
- * @param ssl [in] An SSL object reference.
- * @param fp [in] SHA256 hash to match against
- * @return SSL_OK if the certificate is verified.
- */
-EXP_FUNC int STDCALL ssl_match_spki_sha256(const SSL *ssl, const uint8_t* hash);
-
-/**
- * @brief Retrieve an X.509 distinguished name component.
- *
- * When a handshake is complete and a certificate has been exchanged, then the
- * details of the remote certificate can be retrieved.
- *
- * This will usually be used by a client to check that the server's common
- * name matches the URL.
- *
- * @param ssl [in] An SSL object reference.
- * @param component [in] one of:
- * - SSL_X509_CERT_COMMON_NAME
- * - SSL_X509_CERT_ORGANIZATION
- * - SSL_X509_CERT_ORGANIZATIONAL_NAME
- * - SSL_X509_CA_CERT_COMMON_NAME
- * - SSL_X509_CA_CERT_ORGANIZATION
- * - SSL_X509_CA_CERT_ORGANIZATIONAL_NAME
- * @return The appropriate string (or null if not defined)
- * @note Verification build mode must be enabled.
- */
-EXP_FUNC const char * STDCALL ssl_get_cert_dn(const SSL *ssl, int component);
-
-/**
- * @brief Retrieve a Subject Alternative DNSName
- *
- * When a handshake is complete and a certificate has been exchanged, then the
- * details of the remote certificate can be retrieved.
- *
- * This will usually be used by a client to check that the server's DNS
- * name matches the URL.
- *
- * @param ssl [in] An SSL object reference.
- * @param dnsindex [in] The index of the DNS name to retrieve.
- * @return The appropriate string (or null if not defined)
- * @note Verification build mode must be enabled.
- */
-EXP_FUNC const char * STDCALL ssl_get_cert_subject_alt_dnsname(const SSL *ssl, int dnsindex);
-
-/**
- * @brief Force the client to perform its handshake again.
- *
- * For a client this involves sending another "client hello" message.
- * For the server is means sending a "hello request" message.
- *
- * This is a blocking call on the client (until the handshake completes).
- *
- * @param ssl [in] An SSL object reference.
- * @return SSL_OK if renegotiation instantiation was ok
- */
-EXP_FUNC int STDCALL ssl_renegotiate(SSL *ssl);
-
-/**
- * @brief Process a file that is in binary DER or ASCII PEM format.
- *
- * These are temporary objects that are used to load private keys,
- * certificates etc into memory.
- * @param ssl_ctx [in] The client/server context.
- * @param obj_type [in] The format of the file. Can be one of:
- * - SSL_OBJ_X509_CERT (no password required)
- * - SSL_OBJ_X509_CACERT (no password required)
- * - SSL_OBJ_RSA_KEY (AES128/AES256 PEM encryption supported)
- * - SSL_OBJ_PKCS8 (RC4-128 encrypted data supported)
- * - SSL_OBJ_PKCS12 (RC4-128 encrypted data supported)
- *
- * PEM files are automatically detected (if supported). The object type is
- * also detected, and so is not relevant for these types of files.
- * @param filename [in] The location of a file in DER/PEM format.
- * @param password [in] The password used. Can be null if not required.
- * @return SSL_OK if all ok
- * @note Not available in skeleton build mode.
- */
-EXP_FUNC int STDCALL ssl_obj_load(SSL_CTX *ssl_ctx, int obj_type, const char *filename, const char *password);
-
-/**
- * @brief Process binary data.
- *
- * These are temporary objects that are used to load private keys,
- * certificates etc into memory.
- * @param ssl_ctx [in] The client/server context.
- * @param obj_type [in] The format of the memory data.
- * @param data [in] The binary data to be loaded.
- * @param len [in] The amount of data to be loaded.
- * @param password [in] The password used. Can be null if not required.
- * @return SSL_OK if all ok
- * @see ssl_obj_load for more details on obj_type.
- */
-EXP_FUNC int STDCALL ssl_obj_memory_load(SSL_CTX *ssl_ctx, int obj_type, const uint8_t *data, int len, const char *password);
-
-#ifdef CONFIG_SSL_GENERATE_X509_CERT
-/**
- * @brief Create an X.509 certificate.
- *
- * This certificate is a self-signed v1 cert with a fixed start/stop validity
- * times. It is signed with an internal private key in ssl_ctx.
- *
- * @param ssl_ctx [in] The client/server context.
- * @param options [in] Not used yet.
- * @param dn [in] An array of distinguished name strings. The array is defined
- * by:
- * - SSL_X509_CERT_COMMON_NAME (0)
- *      - If SSL_X509_CERT_COMMON_NAME is empty or not defined, then the
- *        hostname will be used.
- * - SSL_X509_CERT_ORGANIZATION (1)
- *      - If SSL_X509_CERT_ORGANIZATION is empty or not defined, then $USERNAME
- *        will be used.
- * - SSL_X509_CERT_ORGANIZATIONAL_NAME (2)
- *      - SSL_X509_CERT_ORGANIZATIONAL_NAME is optional.
- * @param cert_data [out] The certificate as a sequence of bytes.
- * @return < 0 if an error, or the size of the certificate in bytes.
- * @note cert_data must be freed when there is no more need for it.
- */
-EXP_FUNC int STDCALL ssl_x509_create(SSL_CTX *ssl_ctx, uint32_t options, const char * dn[], uint8_t **cert_data);
-#endif
-
-/**
- * @brief Return the axTLS library version as a string.
- */
-EXP_FUNC const char * STDCALL ssl_version(void);
-
-/** @} */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/platform.txt b/platform.txt
index 1b1354eb8e..7aedacac73 100644
--- a/platform.txt
+++ b/platform.txt
@@ -63,7 +63,7 @@ compiler.S.flags=-c -g -x assembler-with-cpp -MMD -mlongcalls
 compiler.c.elf.flags=-g {compiler.warning_flags} -Os -nostdlib -Wl,--no-check-sections -u app_entry {build.float} -Wl,-static "-L{compiler.sdk.path}/lib" "-L{compiler.sdk.path}/lib/{build.sdk}" "-L{compiler.sdk.path}/ld" "-L{compiler.libc.path}/lib" "-T{build.flash_ld}" -Wl,--gc-sections -Wl,-wrap,system_restart_local -Wl,-wrap,spi_flash_read
 
 compiler.c.elf.cmd=xtensa-lx106-elf-gcc
-compiler.c.elf.libs=-lhal -lphy -lpp -lnet80211 {build.lwip_lib} -lwpa -lcrypto -lmain -lwps -lbearssl -laxtls -lespnow -lsmartconfig -lairkiss -lwpa2 {build.stdcpp_lib} -lm -lc -lgcc
+compiler.c.elf.libs=-lhal -lphy -lpp -lnet80211 {build.lwip_lib} -lwpa -lcrypto -lmain -lwps -lbearssl -lespnow -lsmartconfig -lairkiss -lwpa2 {build.stdcpp_lib} -lm -lc -lgcc
 
 compiler.cpp.cmd=xtensa-lx106-elf-g++
 compiler.cpp.flags=-c {compiler.warning_flags} {build.stacksmash_flags} -Os -g -mlongcalls -mtext-section-literals -fno-rtti -falign-functions=4 {build.stdcpp_level} -MMD -ffunction-sections -fdata-sections {build.exception_flags} {build.sslflags}
diff --git a/tools/platformio-build.py b/tools/platformio-build.py
index 6f315cd69a..30b842728d 100644
--- a/tools/platformio-build.py
+++ b/tools/platformio-build.py
@@ -123,7 +123,7 @@ def scons_patched_match_splitext(path, suffixes=None):
 
     LIBS=[
         "hal", "phy", "pp", "net80211", "wpa", "crypto", "main",
-        "wps", "bearssl", "axtls", "espnow", "smartconfig", "airkiss", "wpa2",
+        "wps", "bearssl", "espnow", "smartconfig", "airkiss", "wpa2",
         "stdc++", "m", "c", "gcc"
     ],
 
diff --git a/tools/sdk/ld/eagle.app.v6.common.ld.h b/tools/sdk/ld/eagle.app.v6.common.ld.h
index 9e233b1ccf..e18d5f731a 100644
--- a/tools/sdk/ld/eagle.app.v6.common.ld.h
+++ b/tools/sdk/ld/eagle.app.v6.common.ld.h
@@ -177,7 +177,6 @@ SECTIONS
     *liblwip6-536-feat.a:(.literal .text .literal.* .text.*)
     *liblwip6-1460-feat.a:(.literal .text .literal.* .text.*)
     *libbearssl.a:(.literal .text .literal.* .text.*)
-    *libaxtls.a:(.literal .text .literal.* .text.*)
     *libat.a:(.literal.* .text.*)
     *libcrypto.a:(.literal.* .text.*)
     *libespnow.a:(.literal.* .text.*)
diff --git a/tools/sdk/lib/libaxtls.a b/tools/sdk/lib/libaxtls.a
deleted file mode 100644
index 1521338260..0000000000
Binary files a/tools/sdk/lib/libaxtls.a and /dev/null differ