SSLClient.h

Go to the documentation of this file.

/* Copyright 2019 OSU OPEnS Lab
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this
 * software and associated documentation files (the "Software"), to deal in the Software
 * without restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include "Client.h"
#include "SSLClientImpl.h"
#include "SSLSession.h"
#include "SSLClientParameters.h"

#ifndef SSLClient_H_
#define SSLClient_H_

template <class C, size_t SessionCache = 1>
class SSLClient : public SSLClientImpl {
/* 
 * static checks
 * I'm a java developer, so I want to ensure that my inheritance is safe.
 * These checks ensure that all the functions we use on class C are
 * actually present on class C. It does this by checking that the
 * class inherits from Client.
 * 
 * Additionally, I ran into a lot of memory issues with large sessions caches.
 * Since each session contains at max 352 bytes of memory, they eat of the
 * stack quite quickly and can cause overflows. As a result, I have added a
 * warning here to discourage the use of more than 3 sessions at a time. Any
 * amount past that will require special modification of this library, and 
 * assumes you know what you are doing.
 */
static_assert(SessionCache > 0 && SessionCache < 255, "There can be no less than one and no more than 255 sessions in the cache!");
static_assert(SessionCache <= 3, "You need to decrease the size of m_iobuf in order to have more than 3 sessions at once, otherwise memory issues will occur.");

public:
    explicit SSLClient( const C& client, 
                        const br_x509_trust_anchor *trust_anchors, 
                        const size_t trust_anchors_num, 
                        const int analog_pin, 
                        const DebugLevel debug = SSL_WARN)
    : SSLClientImpl(trust_anchors, trust_anchors_num, analog_pin, debug) 
    , m_client(client)
    , m_sessions{}
    {
        // set the timeout to a reasonable number (it can always be changes later)
        // SSL Connections take a really long time so we don't want to time out a legitimate thing
        setTimeout(30 * 1000);
    }
    
    explicit SSLClient( const C& client, 
                        const br_x509_trust_anchor *trust_anchors, 
                        const size_t trust_anchors_num, 
                        const int analog_pin, 
                        const DebugLevel debug,
                        const SSLClientParameters* mutual_auth_params)
    : SSLClientImpl(trust_anchors, trust_anchors_num, analog_pin, debug, mutual_auth_params) 
    , m_client(client)
    , m_sessions{}
    {
        // set the timeout to a reasonable number (it can always be changes later)
        // SSL Connections take a really long time so we don't want to time out a legitimate thing
        setTimeout(30 * 1000);
    }

    //========================================
    //= Functions implemented in SSLClientImpl
    //========================================

    int connect(IPAddress ip, uint16_t port) override { return connect_impl(ip, port); }

    int connect(const char *host, uint16_t port) override { return connect_impl(host, port); }

    size_t write(uint8_t b) override { return write_impl(&b, 1); }
    size_t write(const uint8_t *buf, size_t size) override { return write_impl(buf, size); }

    int available() override { return available_impl(); }

    int read() override { uint8_t read_val; return read(&read_val, 1) > 0 ? read_val : -1; };
    int read(uint8_t *buf, size_t size) override { return read_impl(buf, size); }

    int peek() override { return peek_impl(); }

    void flush() override { return flush_impl(); }

    void stop() override { return stop_impl(); }

    uint8_t connected() override { return connected_impl(); }

    //========================================
    //= Functions Not in the Client Interface
    //========================================

    SSLSession& getSession(const char* host, const IPAddress& addr) { return get_session_impl(host, addr); }

    void removeSession(const char* host, const IPAddress& addr) { return remove_session_impl(host, addr); }

    size_t getSessionCount() const override { return SessionCache; }

    operator bool() { return connected() > 0; }
    bool operator==(const bool value) { return bool() == value; }
    bool operator!=(const bool value) { return bool() != value; }
    bool operator==(const C& rhs) { return m_client == rhs; }
    bool operator!=(const C& rhs) { return m_client != rhs; }
    uint16_t localPort() override { return m_client.localPort(); }
    IPAddress remoteIP() override { return m_client.remoteIP(); }
    uint16_t remotePort() override { return m_client.remotePort(); }

    C& getClient() { return m_client; }

protected:
    Client& get_arduino_client() override { return m_client; }
    const Client& get_arduino_client() const override { return m_client; }
    SSLSession* get_session_array() override { return m_sessions; }
    const SSLSession* get_session_array() const override { return m_sessions; }

private:
    // create a copy of the client
    C m_client;
    // also store an array of SSLSessions, so we can resume communication with multiple websites
    SSLSession m_sessions[SessionCache];
};

#endif