src/modules/extra/m_ssl_mbedtls.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com>
   5  *
   6  * This file is part of InspIRCd.  InspIRCd is free software: you can
   7  * redistribute it and/or modify it under the terms of the GNU General Public
   8  * License as published by the Free Software Foundation, version 2.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  12  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  13  * details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 /// $LinkerFlags: -lmbedtls
  20
  21 /// $PackageInfo: require_system("darwin") mbedtls
  22 /// $PackageInfo: require_system("debian" "9.0") libmbedtls-dev
  23 /// $PackageInfo: require_system("ubuntu" "16.04") libmbedtls-dev
  24
  25
  26 #include "inspircd.h"
  27 #include "modules/ssl.h"
  28
  29 #include <mbedtls/ctr_drbg.h>
  30 #include <mbedtls/dhm.h>
  31 #include <mbedtls/ecp.h>
  32 #include <mbedtls/entropy.h>
  33 #include <mbedtls/error.h>
  34 #include <mbedtls/md.h>
  35 #include <mbedtls/pk.h>
  36 #include <mbedtls/ssl.h>
  37 #include <mbedtls/ssl_ciphersuites.h>
  38 #include <mbedtls/version.h>
  39 #include <mbedtls/x509.h>
  40 #include <mbedtls/x509_crt.h>
  41 #include <mbedtls/x509_crl.h>
  42
  43 #ifdef INSPIRCD_MBEDTLS_LIBRARY_DEBUG
  44 #include <mbedtls/debug.h>
  45 #endif
  46
  47 namespace mbedTLS
  48 {
  49         class Exception : public ModuleException
  50         {
  51          public:
  52                 Exception(const std::string& reason)
  53                         : ModuleException(reason) { }
  54         };
  55
  56         std::string ErrorToString(int errcode)
  57         {
  58                 char buf[256];
  59                 mbedtls_strerror(errcode, buf, sizeof(buf));
  60                 return buf;
  61         }
  62
  63         void ThrowOnError(int errcode, const char* msg)
  64         {
  65                 if (errcode != 0)
  66                 {
  67                         std::string reason = msg;
  68                         reason.append(" :").append(ErrorToString(errcode));
  69                         throw Exception(reason);
  70                 }
  71         }
  72
  73         template <typename T, void (*init)(T*), void (*deinit)(T*)>
  74         class RAIIObj
  75         {
  76                 T obj;
  77
  78          public:
  79                 RAIIObj()
  80                 {
  81                         init(&obj);
  82                 }
  83
  84                 ~RAIIObj()
  85                 {
  86                         deinit(&obj);
  87                 }
  88
  89                 T* get() { return &obj; }
  90                 const T* get() const { return &obj; }
  91         };
  92
  93         typedef RAIIObj<mbedtls_entropy_context, mbedtls_entropy_init, mbedtls_entropy_free> Entropy;
  94
  95         class CTRDRBG : private RAIIObj<mbedtls_ctr_drbg_context, mbedtls_ctr_drbg_init, mbedtls_ctr_drbg_free>
  96         {
  97          public:
  98                 bool Seed(Entropy& entropy)
  99                 {
 100                         return (mbedtls_ctr_drbg_seed(get(), mbedtls_entropy_func, entropy.get(), NULL, 0) == 0);
 101                 }
 102
 103                 void SetupConf(mbedtls_ssl_config* conf)
 104                 {
 105                         mbedtls_ssl_conf_rng(conf, mbedtls_ctr_drbg_random, get());
 106                 }
 107         };
 108
 109         class DHParams : public RAIIObj<mbedtls_dhm_context, mbedtls_dhm_init, mbedtls_dhm_free>
 110         {
 111          public:
 112                 void set(const std::string& dhstr)
 113                 {
 114                         // Last parameter is buffer size, must include the terminating null
 115                         int ret = mbedtls_dhm_parse_dhm(get(), reinterpret_cast<const unsigned char*>(dhstr.c_str()), dhstr.size()+1);
 116                         ThrowOnError(ret, "Unable to import DH params");
 117                 }
 118         };
 119
 120         class X509Key : public RAIIObj<mbedtls_pk_context, mbedtls_pk_init, mbedtls_pk_free>
 121         {
 122          public:
 123                 /** Import */
 124                 X509Key(const std::string& keystr)
 125                 {
 126                         int ret = mbedtls_pk_parse_key(get(), reinterpret_cast<const unsigned char*>(keystr.c_str()), keystr.size()+1, NULL, 0);
 127                         ThrowOnError(ret, "Unable to import private key");
 128                 }
 129         };
 130
 131         class Ciphersuites
 132         {
 133                 std::vector<int> list;
 134
 135          public:
 136                 Ciphersuites(const std::string& str)
 137                 {
 138                         // mbedTLS uses the ciphersuite format "TLS-ECDHE-RSA-WITH-AES-128-GCM-SHA256" internally.
 139                         // This is a bit verbose, so we make life a bit simpler for admins by not requiring them to supply the static parts.
 140                         irc::sepstream ss(str, ':');
 141                         for (std::string token; ss.GetToken(token); )
 142                         {
 143                                 // Prepend "TLS-" if not there
 144                                 if (token.compare(0, 4, "TLS-", 4))
 145                                         token.insert(0, "TLS-");
 146
 147                                 const int id = mbedtls_ssl_get_ciphersuite_id(token.c_str());
 148                                 if (!id)
 149                                         throw Exception("Unknown ciphersuite " + token);
 150                                 list.push_back(id);
 151                         }
 152                         list.push_back(0);
 153                 }
 154
 155                 const int* get() const { return &list.front(); }
 156                 bool empty() const { return (list.size() <= 1); }
 157         };
 158
 159         class Curves
 160         {
 161                 std::vector<mbedtls_ecp_group_id> list;
 162
 163          public:
 164                 Curves(const std::string& str)
 165                 {
 166                         irc::sepstream ss(str, ':');
 167                         for (std::string token; ss.GetToken(token); )
 168                         {
 169                                 const mbedtls_ecp_curve_info* curve = mbedtls_ecp_curve_info_from_name(token.c_str());
 170                                 if (!curve)
 171                                         throw Exception("Unknown curve " + token);
 172                                 list.push_back(curve->grp_id);
 173                         }
 174                         list.push_back(MBEDTLS_ECP_DP_NONE);
 175                 }
 176
 177                 const mbedtls_ecp_group_id* get() const { return &list.front(); }
 178                 bool empty() const { return (list.size() <= 1); }
 179         };
 180
 181         class X509CertList : public RAIIObj<mbedtls_x509_crt, mbedtls_x509_crt_init, mbedtls_x509_crt_free>
 182         {
 183          public:
 184                 /** Import or create empty */
 185                 X509CertList(const std::string& certstr, bool allowempty = false)
 186                 {
 187                         if ((allowempty) && (certstr.empty()))
 188                                 return;
 189                         int ret = mbedtls_x509_crt_parse(get(), reinterpret_cast<const unsigned char*>(certstr.c_str()), certstr.size()+1);
 190                         ThrowOnError(ret, "Unable to load certificates");
 191                 }
 192
 193                 bool empty() const { return (get()->raw.p != NULL); }
 194         };
 195
 196         class X509CRL : public RAIIObj<mbedtls_x509_crl, mbedtls_x509_crl_init, mbedtls_x509_crl_free>
 197         {
 198          public:
 199                 X509CRL(const std::string& crlstr)
 200                 {
 201                         if (crlstr.empty())
 202                                 return;
 203                         int ret = mbedtls_x509_crl_parse(get(), reinterpret_cast<const unsigned char*>(crlstr.c_str()), crlstr.size()+1);
 204                         ThrowOnError(ret, "Unable to load CRL");
 205                 }
 206         };
 207
 208         class X509Credentials
 209         {
 210                 /** Private key
 211                  */
 212                 X509Key key;
 213
 214                 /** Certificate list, presented to the peer
 215                  */
 216                 X509CertList certs;
 217
 218          public:
 219                 X509Credentials(const std::string& certstr, const std::string& keystr)
 220                         : key(keystr)
 221                         , certs(certstr)
 222                 {
 223                         // Verify that one of the certs match the private key
 224                         bool found = false;
 225                         for (mbedtls_x509_crt* cert = certs.get(); cert; cert = cert->next)
 226                         {
 227                                 if (mbedtls_pk_check_pair(&cert->pk, key.get()) == 0)
 228                                 {
 229                                         found = true;
 230                                         break;
 231                                 }
 232                         }
 233                         if (!found)
 234                                 throw Exception("Public/private key pair does not match");
 235                 }
 236
 237                 mbedtls_pk_context* getkey() { return key.get(); }
 238                 mbedtls_x509_crt* getcerts() { return certs.get(); }
 239         };
 240
 241         class Context
 242         {
 243                 mbedtls_ssl_config conf;
 244
 245 #ifdef INSPIRCD_MBEDTLS_LIBRARY_DEBUG
 246                 static void DebugLogFunc(void* userptr, int level, const char* file, int line, const char* msg)
 247                 {
 248                         // Remove trailing \n
 249                         size_t len = strlen(msg);
 250                         if ((len > 0) && (msg[len-1] == '\n'))
 251                                 len--;
 252                         ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "%s:%d %.*s", file, line, len, msg);
 253                 }
 254 #endif
 255
 256          public:
 257                 Context(CTRDRBG& ctrdrbg, unsigned int endpoint)
 258                 {
 259                         mbedtls_ssl_config_init(&conf);
 260 #ifdef INSPIRCD_MBEDTLS_LIBRARY_DEBUG
 261                         mbedtls_debug_set_threshold(INT_MAX);
 262                         mbedtls_ssl_conf_dbg(&conf, DebugLogFunc, NULL);
 263 #endif
 264
 265                         // TODO: check ret of mbedtls_ssl_config_defaults
 266                         mbedtls_ssl_config_defaults(&conf, endpoint, MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT);
 267                         ctrdrbg.SetupConf(&conf);
 268                 }
 269
 270                 ~Context()
 271                 {
 272                         mbedtls_ssl_config_free(&conf);
 273                 }
 274
 275                 void SetMinDHBits(unsigned int mindh)
 276                 {
 277                         mbedtls_ssl_conf_dhm_min_bitlen(&conf, mindh);
 278                 }
 279
 280                 void SetDHParams(DHParams& dh)
 281                 {
 282                         mbedtls_ssl_conf_dh_param_ctx(&conf, dh.get());
 283                 }
 284
 285                 void SetX509CertAndKey(X509Credentials& x509cred)
 286                 {
 287                         mbedtls_ssl_conf_own_cert(&conf, x509cred.getcerts(), x509cred.getkey());
 288                 }
 289
 290                 void SetCiphersuites(const Ciphersuites& ciphersuites)
 291                 {
 292                         mbedtls_ssl_conf_ciphersuites(&conf, ciphersuites.get());
 293                 }
 294
 295                 void SetCurves(const Curves& curves)
 296                 {
 297                         mbedtls_ssl_conf_curves(&conf, curves.get());
 298                 }
 299
 300                 void SetVersion(int minver, int maxver)
 301                 {
 302                         // SSL v3 support cannot be enabled
 303                         if (minver)
 304                                 mbedtls_ssl_conf_min_version(&conf, MBEDTLS_SSL_MAJOR_VERSION_3, minver);
 305                         if (maxver)
 306                                 mbedtls_ssl_conf_max_version(&conf, MBEDTLS_SSL_MAJOR_VERSION_3, maxver);
 307                 }
 308
 309                 void SetCA(X509CertList& certs, X509CRL& crl)
 310                 {
 311                         mbedtls_ssl_conf_ca_chain(&conf, certs.get(), crl.get());
 312                 }
 313
 314                 void SetOptionalVerifyCert()
 315                 {
 316                         mbedtls_ssl_conf_authmode(&conf, MBEDTLS_SSL_VERIFY_OPTIONAL);
 317                 }
 318
 319                 const mbedtls_ssl_config* GetConf() const { return &conf; }
 320         };
 321
 322         class Hash
 323         {
 324                 const mbedtls_md_info_t* md;
 325
 326                 /** Buffer where cert hashes are written temporarily
 327                  */
 328                 mutable std::vector<unsigned char> buf;
 329
 330          public:
 331                 Hash(std::string hashstr)
 332                 {
 333                         std::transform(hashstr.begin(), hashstr.end(), hashstr.begin(), ::toupper);
 334                         md = mbedtls_md_info_from_string(hashstr.c_str());
 335                         if (!md)
 336                                 throw Exception("Unknown hash: " + hashstr);
 337
 338                         buf.resize(mbedtls_md_get_size(md));
 339                 }
 340
 341                 std::string hash(const unsigned char* input, size_t length) const
 342                 {
 343                         mbedtls_md(md, input, length, &buf.front());
 344                         return BinToHex(&buf.front(), buf.size());
 345                 }
 346         };
 347
 348         class Profile : public refcountbase
 349         {
 350                 /** Name of this profile
 351                  */
 352                 const std::string name;
 353
 354                 X509Credentials x509cred;
 355
 356                 /** Ciphersuites to use
 357                  */
 358                 Ciphersuites ciphersuites;
 359
 360                 /** Curves accepted for use in ECDHE and in the peer's end-entity certificate
 361                  */
 362                 Curves curves;
 363
 364                 Context serverctx;
 365                 Context clientctx;
 366
 367                 DHParams dhparams;
 368
 369                 X509CertList cacerts;
 370
 371                 X509CRL crl;
 372
 373                 /** Hashing algorithm to use when generating certificate fingerprints
 374                  */
 375                 Hash hash;
 376
 377                 /** Rough max size of records to send
 378                  */
 379                 const unsigned int outrecsize;
 380
 381                 Profile(const std::string& profilename, const std::string& certstr, const std::string& keystr,
 382                                 const std::string& dhstr, unsigned int mindh, const std::string& hashstr,
 383                                 const std::string& ciphersuitestr, const std::string& curvestr,
 384                                 const std::string& castr, const std::string& crlstr,
 385                                 unsigned int recsize,
 386                                 CTRDRBG& ctrdrbg,
 387                                 int minver, int maxver,
 388                                 bool requestclientcert
 389                                 )
 390                         : name(profilename)
 391                         , x509cred(certstr, keystr)
 392                         , ciphersuites(ciphersuitestr)
 393                         , curves(curvestr)
 394                         , serverctx(ctrdrbg, MBEDTLS_SSL_IS_SERVER)
 395                         , clientctx(ctrdrbg, MBEDTLS_SSL_IS_CLIENT)
 396                         , cacerts(castr, true)
 397                         , crl(crlstr)
 398                         , hash(hashstr)
 399                         , outrecsize(recsize)
 400                 {
 401                         serverctx.SetX509CertAndKey(x509cred);
 402                         clientctx.SetX509CertAndKey(x509cred);
 403                         clientctx.SetMinDHBits(mindh);
 404
 405                         if (!ciphersuites.empty())
 406                         {
 407                                 serverctx.SetCiphersuites(ciphersuites);
 408                                 clientctx.SetCiphersuites(ciphersuites);
 409                         }
 410
 411                         if (!curves.empty())
 412                         {
 413                                 serverctx.SetCurves(curves);
 414                                 clientctx.SetCurves(curves);
 415                         }
 416
 417                         serverctx.SetVersion(minver, maxver);
 418                         clientctx.SetVersion(minver, maxver);
 419
 420                         if (!dhstr.empty())
 421                         {
 422                                 dhparams.set(dhstr);
 423                                 serverctx.SetDHParams(dhparams);
 424                         }
 425
 426                         clientctx.SetOptionalVerifyCert();
 427                         clientctx.SetCA(cacerts, crl);
 428                         // The default for servers is to not request a client certificate from the peer
 429                         if (requestclientcert)
 430                         {
 431                                 serverctx.SetOptionalVerifyCert();
 432                                 serverctx.SetCA(cacerts, crl);
 433                         }
 434                 }
 435
 436                 static std::string ReadFile(const std::string& filename)
 437                 {
 438                         FileReader reader(filename);
 439                         std::string ret = reader.GetString();
 440                         if (ret.empty())
 441                                 throw Exception("Cannot read file " + filename);
 442                         return ret;
 443                 }
 444
 445          public:
 446                 static reference<Profile> Create(const std::string& profilename, ConfigTag* tag, CTRDRBG& ctr_drbg)
 447                 {
 448                         const std::string certstr = ReadFile(tag->getString("certfile", "cert.pem"));
 449                         const std::string keystr = ReadFile(tag->getString("keyfile", "key.pem"));
 450                         const std::string dhstr = ReadFile(tag->getString("dhfile", "dhparams.pem"));
 451
 452                         const std::string ciphersuitestr = tag->getString("ciphersuites");
 453                         const std::string curvestr = tag->getString("curves");
 454                         unsigned int mindh = tag->getInt("mindhbits", 2048);
 455                         std::string hashstr = tag->getString("hash", "sha256");
 456
 457                         std::string crlstr;
 458                         std::string castr = tag->getString("cafile");
 459                         if (!castr.empty())
 460                         {
 461                                 castr = ReadFile(castr);
 462                                 crlstr = tag->getString("crlfile");
 463                                 if (!crlstr.empty())
 464                                         crlstr = ReadFile(crlstr);
 465                         }
 466
 467                         int minver = tag->getInt("minver");
 468                         int maxver = tag->getInt("maxver");
 469                         unsigned int outrecsize = tag->getInt("outrecsize", 2048, 512, 16384);
 470                         const bool requestclientcert = tag->getBool("requestclientcert", true);
 471                         return new Profile(profilename, certstr, keystr, dhstr, mindh, hashstr, ciphersuitestr, curvestr, castr, crlstr, outrecsize, ctr_drbg, minver, maxver, requestclientcert);
 472                 }
 473
 474                 /** Set up the given session with the settings in this profile
 475                  */
 476                 void SetupClientSession(mbedtls_ssl_context* sess)
 477                 {
 478                         mbedtls_ssl_setup(sess, clientctx.GetConf());
 479                 }
 480
 481                 void SetupServerSession(mbedtls_ssl_context* sess)
 482                 {
 483                         mbedtls_ssl_setup(sess, serverctx.GetConf());
 484                 }
 485
 486                 const std::string& GetName() const { return name; }
 487                 X509Credentials& GetX509Credentials() { return x509cred; }
 488                 unsigned int GetOutgoingRecordSize() const { return outrecsize; }
 489                 const Hash& GetHash() const { return hash; }
 490         };
 491 }
 492
 493 class mbedTLSIOHook : public SSLIOHook
 494 {
 495         enum Status
 496         {
 497                 ISSL_NONE,
 498                 ISSL_HANDSHAKING,
 499                 ISSL_HANDSHAKEN
 500         };
 501
 502         mbedtls_ssl_context sess;
 503         Status status;
 504         reference<mbedTLS::Profile> profile;
 505
 506         void CloseSession()
 507         {
 508                 if (status == ISSL_NONE)
 509                         return;
 510
 511                 mbedtls_ssl_close_notify(&sess);
 512                 mbedtls_ssl_free(&sess);
 513                 certificate = NULL;
 514                 status = ISSL_NONE;
 515         }
 516
 517         // Returns 1 if handshake succeeded, 0 if it is still in progress, -1 if it failed
 518         int Handshake(StreamSocket* sock)
 519         {
 520                 int ret = mbedtls_ssl_handshake(&sess);
 521                 if (ret == 0)
 522                 {
 523                         // Change the seesion state
 524                         this->status = ISSL_HANDSHAKEN;
 525
 526                         VerifyCertificate();
 527
 528                         // Finish writing, if any left
 529                         SocketEngine::ChangeEventMask(sock, FD_WANT_POLL_READ | FD_WANT_NO_WRITE | FD_ADD_TRIAL_WRITE);
 530
 531                         return 1;
 532                 }
 533
 534                 this->status = ISSL_HANDSHAKING;
 535                 if (ret == MBEDTLS_ERR_SSL_WANT_READ)
 536                 {
 537                         SocketEngine::ChangeEventMask(sock, FD_WANT_POLL_READ | FD_WANT_NO_WRITE);
 538                         return 0;
 539                 }
 540                 else if (ret == MBEDTLS_ERR_SSL_WANT_WRITE)
 541                 {
 542                         SocketEngine::ChangeEventMask(sock, FD_WANT_NO_READ | FD_WANT_SINGLE_WRITE);
 543                         return 0;
 544                 }
 545
 546                 sock->SetError("Handshake Failed - " + mbedTLS::ErrorToString(ret));
 547                 CloseSession();
 548                 return -1;
 549         }
 550
 551         // Returns 1 if application I/O should proceed, 0 if it must wait for the underlying protocol to progress, -1 on fatal error
 552         int PrepareIO(StreamSocket* sock)
 553         {
 554                 if (status == ISSL_HANDSHAKEN)
 555                         return 1;
 556                 else if (status == ISSL_HANDSHAKING)
 557                 {
 558                         // The handshake isn't finished, try to finish it
 559                         return Handshake(sock);
 560                 }
 561
 562                 CloseSession();
 563                 sock->SetError("No SSL session");
 564                 return -1;
 565         }
 566
 567         void VerifyCertificate()
 568         {
 569                 this->certificate = new ssl_cert;
 570                 const mbedtls_x509_crt* const cert = mbedtls_ssl_get_peer_cert(&sess);
 571                 if (!cert)
 572                 {
 573                         certificate->error = "No client certificate sent";
 574                         return;
 575                 }
 576
 577                 // If there is a certificate we can always generate a fingerprint
 578                 certificate->fingerprint = profile->GetHash().hash(cert->raw.p, cert->raw.len);
 579
 580                 // At this point mbedTLS verified the cert already, we just need to check the results
 581                 const uint32_t flags = mbedtls_ssl_get_verify_result(&sess);
 582                 if (flags == 0xFFFFFFFF)
 583                 {
 584                         certificate->error = "Internal error during verification";
 585                         return;
 586                 }
 587
 588                 if (flags == 0)
 589                 {
 590                         // Verification succeeded
 591                         certificate->trusted = true;
 592                 }
 593                 else
 594                 {
 595                         // Verification failed
 596                         certificate->trusted = false;
 597                         if ((flags & MBEDTLS_X509_BADCERT_EXPIRED) || (flags & MBEDTLS_X509_BADCERT_FUTURE))
 598                                 certificate->error = "Not activated, or expired certificate";
 599                 }
 600
 601                 certificate->unknownsigner = (flags & MBEDTLS_X509_BADCERT_NOT_TRUSTED);
 602                 certificate->revoked = (flags & MBEDTLS_X509_BADCERT_REVOKED);
 603                 certificate->invalid = ((flags & MBEDTLS_X509_BADCERT_BAD_KEY) || (flags & MBEDTLS_X509_BADCERT_BAD_MD) || (flags & MBEDTLS_X509_BADCERT_BAD_PK));
 604
 605                 GetDNString(&cert->subject, certificate->dn);
 606                 GetDNString(&cert->issuer, certificate->issuer);
 607         }
 608
 609         static void GetDNString(const mbedtls_x509_name* x509name, std::string& out)
 610         {
 611                 char buf[512];
 612                 const int ret = mbedtls_x509_dn_gets(buf, sizeof(buf), x509name);
 613                 if (ret <= 0)
 614                         return;
 615
 616                 out.assign(buf, ret);
 617         }
 618
 619         static int Pull(void* userptr, unsigned char* buffer, size_t size)
 620         {
 621                 StreamSocket* const sock = reinterpret_cast<StreamSocket*>(userptr);
 622                 if (sock->GetEventMask() & FD_READ_WILL_BLOCK)
 623                         return MBEDTLS_ERR_SSL_WANT_READ;
 624
 625                 const int ret = SocketEngine::Recv(sock, reinterpret_cast<char*>(buffer), size, 0);
 626                 if (ret < (int)size)
 627                 {
 628                         SocketEngine::ChangeEventMask(sock, FD_READ_WILL_BLOCK);
 629                         if ((ret == -1) && (SocketEngine::IgnoreError()))
 630                                 return MBEDTLS_ERR_SSL_WANT_READ;
 631                 }
 632                 return ret;
 633         }
 634
 635         static int Push(void* userptr, const unsigned char* buffer, size_t size)
 636         {
 637                 StreamSocket* const sock = reinterpret_cast<StreamSocket*>(userptr);
 638                 if (sock->GetEventMask() & FD_WRITE_WILL_BLOCK)
 639                         return MBEDTLS_ERR_SSL_WANT_WRITE;
 640
 641                 const int ret = SocketEngine::Send(sock, buffer, size, 0);
 642                 if (ret < (int)size)
 643                 {
 644                         SocketEngine::ChangeEventMask(sock, FD_WRITE_WILL_BLOCK);
 645                         if ((ret == -1) && (SocketEngine::IgnoreError()))
 646                                 return MBEDTLS_ERR_SSL_WANT_WRITE;
 647                 }
 648                 return ret;
 649         }
 650
 651  public:
 652         mbedTLSIOHook(IOHookProvider* hookprov, StreamSocket* sock, bool isserver, mbedTLS::Profile* sslprofile)
 653                 : SSLIOHook(hookprov)
 654                 , status(ISSL_NONE)
 655                 , profile(sslprofile)
 656         {
 657                 mbedtls_ssl_init(&sess);
 658                 if (isserver)
 659                         profile->SetupServerSession(&sess);
 660                 else
 661                         profile->SetupClientSession(&sess);
 662
 663                 mbedtls_ssl_set_bio(&sess, reinterpret_cast<void*>(sock), Push, Pull, NULL);
 664
 665                 sock->AddIOHook(this);
 666                 Handshake(sock);
 667         }
 668
 669         void OnStreamSocketClose(StreamSocket* sock) CXX11_OVERRIDE
 670         {
 671                 CloseSession();
 672         }
 673
 674         int OnStreamSocketRead(StreamSocket* sock, std::string& recvq) CXX11_OVERRIDE
 675         {
 676                 // Finish handshake if needed
 677                 int prepret = PrepareIO(sock);
 678                 if (prepret <= 0)
 679                         return prepret;
 680
 681                 // If we resumed the handshake then this->status will be ISSL_HANDSHAKEN.
 682                 char* const readbuf = ServerInstance->GetReadBuffer();
 683                 const size_t readbufsize = ServerInstance->Config->NetBufferSize;
 684                 int ret = mbedtls_ssl_read(&sess, reinterpret_cast<unsigned char*>(readbuf), readbufsize);
 685                 if (ret > 0)
 686                 {
 687                         recvq.append(readbuf, ret);
 688
 689                         // Schedule a read if there is still data in the mbedTLS buffer
 690                         if (mbedtls_ssl_get_bytes_avail(&sess) > 0)
 691                                 SocketEngine::ChangeEventMask(sock, FD_ADD_TRIAL_READ);
 692                         return 1;
 693                 }
 694                 else if (ret == MBEDTLS_ERR_SSL_WANT_READ)
 695                 {
 696                         SocketEngine::ChangeEventMask(sock, FD_WANT_POLL_READ);
 697                         return 0;
 698                 }
 699                 else if (ret == MBEDTLS_ERR_SSL_WANT_WRITE)
 700                 {
 701                         SocketEngine::ChangeEventMask(sock, FD_WANT_NO_READ | FD_WANT_SINGLE_WRITE);
 702                         return 0;
 703                 }
 704                 else if (ret == 0)
 705                 {
 706                         sock->SetError("Connection closed");
 707                         CloseSession();
 708                         return -1;
 709                 }
 710                 else // error or MBEDTLS_ERR_SSL_CLIENT_RECONNECT which we treat as an error
 711                 {
 712                         sock->SetError(mbedTLS::ErrorToString(ret));
 713                         CloseSession();
 714                         return -1;
 715                 }
 716         }
 717
 718         int OnStreamSocketWrite(StreamSocket* sock, StreamSocket::SendQueue& sendq) CXX11_OVERRIDE
 719         {
 720                 // Finish handshake if needed
 721                 int prepret = PrepareIO(sock);
 722                 if (prepret <= 0)
 723                         return prepret;
 724
 725                 // Session is ready for transferring application data
 726                 while (!sendq.empty())
 727                 {
 728                         FlattenSendQueue(sendq, profile->GetOutgoingRecordSize());
 729                         const StreamSocket::SendQueue::Element& buffer = sendq.front();
 730                         int ret = mbedtls_ssl_write(&sess, reinterpret_cast<const unsigned char*>(buffer.data()), buffer.length());
 731                         if (ret == (int)buffer.length())
 732                         {
 733                                 // Wrote entire record, continue sending
 734                                 sendq.pop_front();
 735                         }
 736                         else if (ret > 0)
 737                         {
 738                                 sendq.erase_front(ret);
 739                                 SocketEngine::ChangeEventMask(sock, FD_WANT_SINGLE_WRITE);
 740                                 return 0;
 741                         }
 742                         else if (ret == 0)
 743                         {
 744                                 sock->SetError("Connection closed");
 745                                 CloseSession();
 746                                 return -1;
 747                         }
 748                         else if (ret == MBEDTLS_ERR_SSL_WANT_WRITE)
 749                         {
 750                                 SocketEngine::ChangeEventMask(sock, FD_WANT_SINGLE_WRITE);
 751                                 return 0;
 752                         }
 753                         else if (ret == MBEDTLS_ERR_SSL_WANT_READ)
 754                         {
 755                                 SocketEngine::ChangeEventMask(sock, FD_WANT_POLL_READ);
 756                                 return 0;
 757                         }
 758                         else
 759                         {
 760                                 sock->SetError(mbedTLS::ErrorToString(ret));
 761                                 CloseSession();
 762                                 return -1;
 763                         }
 764                 }
 765
 766                 SocketEngine::ChangeEventMask(sock, FD_WANT_NO_WRITE);
 767                 return 1;
 768         }
 769
 770         void GetCiphersuite(std::string& out) const CXX11_OVERRIDE
 771         {
 772                 if (!IsHandshakeDone())
 773                         return;
 774                 out.append(mbedtls_ssl_get_version(&sess)).push_back('-');
 775
 776                 // All mbedTLS ciphersuite names currently begin with "TLS-" which provides no useful information so skip it, but be prepared if it changes
 777                 const char* const ciphersuitestr = mbedtls_ssl_get_ciphersuite(&sess);
 778                 const char prefix[] = "TLS-";
 779                 unsigned int skip = sizeof(prefix)-1;
 780                 if (strncmp(ciphersuitestr, prefix, sizeof(prefix)-1))
 781                         skip = 0;
 782                 out.append(ciphersuitestr + skip);
 783         }
 784
 785         bool GetServerName(std::string& out) const CXX11_OVERRIDE
 786         {
 787                 // TODO: Implement SNI support.
 788                 return false;
 789         }
 790
 791         bool IsHandshakeDone() const { return (status == ISSL_HANDSHAKEN); }
 792 };
 793
 794 class mbedTLSIOHookProvider : public refcountbase, public IOHookProvider
 795 {
 796         reference<mbedTLS::Profile> profile;
 797
 798  public:
 799         mbedTLSIOHookProvider(Module* mod, mbedTLS::Profile* prof)
 800                 : IOHookProvider(mod, "ssl/" + prof->GetName(), IOHookProvider::IOH_SSL)
 801                 , profile(prof)
 802         {
 803                 ServerInstance->Modules->AddService(*this);
 804         }
 805
 806         ~mbedTLSIOHookProvider()
 807         {
 808                 ServerInstance->Modules->DelService(*this);
 809         }
 810
 811         void OnAccept(StreamSocket* sock, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server) CXX11_OVERRIDE
 812         {
 813                 new mbedTLSIOHook(this, sock, true, profile);
 814         }
 815
 816         void OnConnect(StreamSocket* sock) CXX11_OVERRIDE
 817         {
 818                 new mbedTLSIOHook(this, sock, false, profile);
 819         }
 820 };
 821
 822 class ModuleSSLmbedTLS : public Module
 823 {
 824         typedef std::vector<reference<mbedTLSIOHookProvider> > ProfileList;
 825
 826         mbedTLS::Entropy entropy;
 827         mbedTLS::CTRDRBG ctr_drbg;
 828         ProfileList profiles;
 829
 830         void ReadProfiles()
 831         {
 832                 // First, store all profiles in a new, temporary container. If no problems occur, swap the two
 833                 // containers; this way if something goes wrong we can go back and continue using the current profiles,
 834                 // avoiding unpleasant situations where no new SSL connections are possible.
 835                 ProfileList newprofiles;
 836
 837                 ConfigTagList tags = ServerInstance->Config->ConfTags("sslprofile");
 838                 if (tags.first == tags.second)
 839                 {
 840                         // No <sslprofile> tags found, create a profile named "mbedtls" from settings in the <mbedtls> block
 841                         const std::string defname = "mbedtls";
 842                         ConfigTag* tag = ServerInstance->Config->ConfValue(defname);
 843                         ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "No <sslprofile> tags found; using settings from the <mbedtls> tag");
 844
 845                         try
 846                         {
 847                                 reference<mbedTLS::Profile> profile(mbedTLS::Profile::Create(defname, tag, ctr_drbg));
 848                                 newprofiles.push_back(new mbedTLSIOHookProvider(this, profile));
 849                         }
 850                         catch (CoreException& ex)
 851                         {
 852                                 throw ModuleException("Error while initializing the default SSL profile - " + ex.GetReason());
 853                         }
 854                 }
 855
 856                 for (ConfigIter i = tags.first; i != tags.second; ++i)
 857                 {
 858                         ConfigTag* tag = i->second;
 859                         if (tag->getString("provider") != "mbedtls")
 860                                 continue;
 861
 862                         std::string name = tag->getString("name");
 863                         if (name.empty())
 864                         {
 865                                 ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Ignoring <sslprofile> tag without name at " + tag->getTagLocation());
 866                                 continue;
 867                         }
 868
 869                         reference<mbedTLS::Profile> profile;
 870                         try
 871                         {
 872                                 profile = mbedTLS::Profile::Create(name, tag, ctr_drbg);
 873                         }
 874                         catch (CoreException& ex)
 875                         {
 876                                 throw ModuleException("Error while initializing SSL profile \"" + name + "\" at " + tag->getTagLocation() + " - " + ex.GetReason());
 877                         }
 878
 879                         newprofiles.push_back(new mbedTLSIOHookProvider(this, profile));
 880                 }
 881
 882                 // New profiles are ok, begin using them
 883                 // Old profiles are deleted when their refcount drops to zero
 884                 profiles.swap(newprofiles);
 885         }
 886
 887  public:
 888         void init() CXX11_OVERRIDE
 889         {
 890                 char verbuf[16]; // Should be at least 9 bytes in size
 891                 mbedtls_version_get_string(verbuf);
 892                 ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "mbedTLS lib version %s module was compiled for " MBEDTLS_VERSION_STRING, verbuf);
 893
 894                 if (!ctr_drbg.Seed(entropy))
 895                         throw ModuleException("CTR DRBG seed failed");
 896                 ReadProfiles();
 897         }
 898
 899         void OnModuleRehash(User* user, const std::string &param) CXX11_OVERRIDE
 900         {
 901                 if (param != "ssl")
 902                         return;
 903
 904                 try
 905                 {
 906                         ReadProfiles();
 907                 }
 908                 catch (ModuleException& ex)
 909                 {
 910                         ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, ex.GetReason() + " Not applying settings.");
 911                 }
 912         }
 913
 914         void OnCleanup(ExtensionItem::ExtensibleType type, Extensible* item) CXX11_OVERRIDE
 915         {
 916                 if (type != ExtensionItem::EXT_USER)
 917                         return;
 918
 919                 LocalUser* user = IS_LOCAL(static_cast<User*>(item));
 920                 if ((user) && (user->eh.GetModHook(this)))
 921                 {
 922                         // User is using SSL, they're a local user, and they're using our IOHook.
 923                         // Potentially there could be multiple SSL modules loaded at once on different ports.
 924                         ServerInstance->Users.QuitUser(user, "SSL module unloading");
 925                 }
 926         }
 927
 928         ModResult OnCheckReady(LocalUser* user) CXX11_OVERRIDE
 929         {
 930                 const mbedTLSIOHook* const iohook = static_cast<mbedTLSIOHook*>(user->eh.GetModHook(this));
 931                 if ((iohook) && (!iohook->IsHandshakeDone()))
 932                         return MOD_RES_DENY;
 933                 return MOD_RES_PASSTHRU;
 934         }
 935
 936         Version GetVersion() CXX11_OVERRIDE
 937         {
 938                 return Version("Provides SSL support via mbedTLS (PolarSSL)", VF_VENDOR);
 939         }
 940 };
 941
 942 MODULE_INIT(ModuleSSLmbedTLS)