falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3759 Commits
16 Branches
16GB
Tree: 88c8018d8b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '88c8018d8b'
${ noResults }
Carla/source/modules/hylia/link/asio/ssl/impl/context.ipp

961 lines
22KB
Raw Blame History 

  1. //

  2. // ssl/impl/context.ipp

  3. // ~~~~~~~~~~~~~~~~~~~~

  4. //

  5. // Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com

  6. // Copyright (c) 2005-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)

  7. //

  8. // Distributed under the Boost Software License, Version 1.0. (See accompanying

  9. // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

  10. //

  11. 

  12. #ifndef ASIO_SSL_IMPL_CONTEXT_IPP

  13. #define ASIO_SSL_IMPL_CONTEXT_IPP

  14. 

  15. #if defined(_MSC_VER) && (_MSC_VER >= 1200)

  16. # pragma once

  17. #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)

  18. 

  19. #include "asio/detail/config.hpp"

  20. 

  21. #include <cstring>

  22. #include "asio/detail/throw_error.hpp"

  23. #include "asio/error.hpp"

  24. #include "asio/ssl/context.hpp"

  25. #include "asio/ssl/error.hpp"

  26. 

  27. #include "asio/detail/push_options.hpp"

  28. 

  29. namespace asio {

  30. namespace ssl {

  31. 

  32. struct context::bio_cleanup

  33. {

  34.   BIO* p;

  35.   ~bio_cleanup() { if (p) ::BIO_free(p); }

  36. };

  37. 

  38. struct context::x509_cleanup

  39. {

  40.   X509* p;

  41.   ~x509_cleanup() { if (p) ::X509_free(p); }

  42. };

  43. 

  44. struct context::evp_pkey_cleanup

  45. {

  46.   EVP_PKEY* p;

  47.   ~evp_pkey_cleanup() { if (p) ::EVP_PKEY_free(p); }

  48. };

  49. 

  50. struct context::rsa_cleanup

  51. {

  52.   RSA* p;

  53.   ~rsa_cleanup() { if (p) ::RSA_free(p); }

  54. };

  55. 

  56. struct context::dh_cleanup

  57. {

  58.   DH* p;

  59.   ~dh_cleanup() { if (p) ::DH_free(p); }

  60. };

  61. 

  62. context::context(context::method m)

  63.   : handle_(0)

  64. {

  65.   ::ERR_clear_error();

  66. 

  67.   switch (m)

  68.   {

  69. #if defined(OPENSSL_NO_SSL2)

  70.   case context::sslv2:

  71.   case context::sslv2_client:

  72.   case context::sslv2_server:

  73.     asio::detail::throw_error(

  74.         asio::error::invalid_argument, "context");

  75.     break;

  76. #else // defined(OPENSSL_NO_SSL2)

  77.   case context::sslv2:

  78.     handle_ = ::SSL_CTX_new(::SSLv2_method());

  79.     break;

  80.   case context::sslv2_client:

  81.     handle_ = ::SSL_CTX_new(::SSLv2_client_method());

  82.     break;

  83.   case context::sslv2_server:

  84.     handle_ = ::SSL_CTX_new(::SSLv2_server_method());

  85.     break;

  86. #endif // defined(OPENSSL_NO_SSL2)

  87.   case context::sslv3:

  88.     handle_ = ::SSL_CTX_new(::SSLv3_method());

  89.     break;

  90.   case context::sslv3_client:

  91.     handle_ = ::SSL_CTX_new(::SSLv3_client_method());

  92.     break;

  93.   case context::sslv3_server:

  94.     handle_ = ::SSL_CTX_new(::SSLv3_server_method());

  95.     break;

  96.   case context::tlsv1:

  97.     handle_ = ::SSL_CTX_new(::TLSv1_method());

  98.     break;

  99.   case context::tlsv1_client:

  100.     handle_ = ::SSL_CTX_new(::TLSv1_client_method());

  101.     break;

  102.   case context::tlsv1_server:

  103.     handle_ = ::SSL_CTX_new(::TLSv1_server_method());

  104.     break;

  105.   case context::sslv23:

  106.     handle_ = ::SSL_CTX_new(::SSLv23_method());

  107.     break;

  108.   case context::sslv23_client:

  109.     handle_ = ::SSL_CTX_new(::SSLv23_client_method());

  110.     break;

  111.   case context::sslv23_server:

  112.     handle_ = ::SSL_CTX_new(::SSLv23_server_method());

  113.     break;

  114. #if defined(SSL_TXT_TLSV1_1)

  115.   case context::tlsv11:

  116.     handle_ = ::SSL_CTX_new(::TLSv1_1_method());

  117.     break;

  118.   case context::tlsv11_client:

  119.     handle_ = ::SSL_CTX_new(::TLSv1_1_client_method());

  120.     break;

  121.   case context::tlsv11_server:

  122.     handle_ = ::SSL_CTX_new(::TLSv1_1_server_method());

  123.     break;

  124. #else // defined(SSL_TXT_TLSV1_1)

  125.   case context::tlsv11:

  126.   case context::tlsv11_client:

  127.   case context::tlsv11_server:

  128.     asio::detail::throw_error(

  129.         asio::error::invalid_argument, "context");

  130.     break;

  131. #endif // defined(SSL_TXT_TLSV1_1)

  132. #if defined(SSL_TXT_TLSV1_2)

  133.   case context::tlsv12:

  134.     handle_ = ::SSL_CTX_new(::TLSv1_2_method());

  135.     break;

  136.   case context::tlsv12_client:

  137.     handle_ = ::SSL_CTX_new(::TLSv1_2_client_method());

  138.     break;

  139.   case context::tlsv12_server:

  140.     handle_ = ::SSL_CTX_new(::TLSv1_2_server_method());

  141.     break;

  142. #else // defined(SSL_TXT_TLSV1_2) 

  143.   case context::tlsv12:

  144.   case context::tlsv12_client:

  145.   case context::tlsv12_server:

  146.     asio::detail::throw_error(

  147.         asio::error::invalid_argument, "context");

  148.     break;

  149. #endif // defined(SSL_TXT_TLSV1_2) 

  150.   default:

  151.     handle_ = ::SSL_CTX_new(0);

  152.     break;

  153.   }

  154. 

  155.   if (handle_ == 0)

  156.   {

  157.     asio::error_code ec(

  158.         static_cast<int>(::ERR_get_error()),

  159.         asio::error::get_ssl_category());

  160.     asio::detail::throw_error(ec, "context");

  161.   }

  162. 

  163.   set_options(no_compression);

  164. }

  165. 

  166. #if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)

  167. context::context(context&& other)

  168. {

  169.   handle_ = other.handle_;

  170.   other.handle_ = 0;

  171. }

  172. 

  173. context& context::operator=(context&& other)

  174. {

  175.   context tmp(ASIO_MOVE_CAST(context)(*this));

  176.   handle_ = other.handle_;

  177.   other.handle_ = 0;

  178.   return *this;

  179. }

  180. #endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)

  181. 

  182. context::~context()

  183. {

  184.   if (handle_)

  185.   {

  186.     if (handle_->default_passwd_callback_userdata)

  187.     {

  188.       detail::password_callback_base* callback =

  189.         static_cast<detail::password_callback_base*>(

  190.             handle_->default_passwd_callback_userdata);

  191.       delete callback;

  192.       handle_->default_passwd_callback_userdata = 0;

  193.     }

  194. 

  195.     if (SSL_CTX_get_app_data(handle_))

  196.     {

  197.       detail::verify_callback_base* callback =

  198.         static_cast<detail::verify_callback_base*>(

  199.             SSL_CTX_get_app_data(handle_));

  200.       delete callback;

  201.       SSL_CTX_set_app_data(handle_, 0);

  202.     }

  203. 

  204.     ::SSL_CTX_free(handle_);

  205.   }

  206. }

  207. 

  208. context::native_handle_type context::native_handle()

  209. {

  210.   return handle_;

  211. }

  212. 

  213. void context::clear_options(context::options o)

  214. {

  215.   asio::error_code ec;

  216.   clear_options(o, ec);

  217.   asio::detail::throw_error(ec, "clear_options");

  218. }

  219. 

  220. asio::error_code context::clear_options(

  221.     context::options o, asio::error_code& ec)

  222. {

  223. #if (OPENSSL_VERSION_NUMBER >= 0x009080DFL) \

  224.   && (OPENSSL_VERSION_NUMBER != 0x00909000L)

  225. # if !defined(SSL_OP_NO_COMPRESSION)

  226.   if ((o & context::no_compression) != 0)

  227.   {

  228. # if (OPENSSL_VERSION_NUMBER >= 0x00908000L)

  229.     handle_->comp_methods = SSL_COMP_get_compression_methods();

  230. # endif // (OPENSSL_VERSION_NUMBER >= 0x00908000L)

  231.     o ^= context::no_compression;

  232.   }

  233. # endif // !defined(SSL_OP_NO_COMPRESSION)

  234. 

  235.   ::SSL_CTX_clear_options(handle_, o);

  236. 

  237.   ec = asio::error_code();

  238. #else // (OPENSSL_VERSION_NUMBER >= 0x009080DFL)

  239.       //   && (OPENSSL_VERSION_NUMBER != 0x00909000L)

  240.   (void)o;

  241.   ec = asio::error::operation_not_supported;

  242. #endif // (OPENSSL_VERSION_NUMBER >= 0x009080DFL)

  243.        //   && (OPENSSL_VERSION_NUMBER != 0x00909000L)

  244.   return ec;

  245. }

  246. 

  247. void context::set_options(context::options o)

  248. {

  249.   asio::error_code ec;

  250.   set_options(o, ec);

  251.   asio::detail::throw_error(ec, "set_options");

  252. }

  253. 

  254. asio::error_code context::set_options(

  255.     context::options o, asio::error_code& ec)

  256. {

  257. #if !defined(SSL_OP_NO_COMPRESSION)

  258.   if ((o & context::no_compression) != 0)

  259.   {

  260. #if (OPENSSL_VERSION_NUMBER >= 0x00908000L)

  261.     handle_->comp_methods =

  262.       asio::ssl::detail::openssl_init<>::get_null_compression_methods();

  263. #endif // (OPENSSL_VERSION_NUMBER >= 0x00908000L)

  264.     o ^= context::no_compression;

  265.   }

  266. #endif // !defined(SSL_OP_NO_COMPRESSION)

  267. 

  268.   ::SSL_CTX_set_options(handle_, o);

  269. 

  270.   ec = asio::error_code();

  271.   return ec;

  272. }

  273. 

  274. void context::set_verify_mode(verify_mode v)

  275. {

  276.   asio::error_code ec;

  277.   set_verify_mode(v, ec);

  278.   asio::detail::throw_error(ec, "set_verify_mode");

  279. }

  280. 

  281. asio::error_code context::set_verify_mode(

  282.     verify_mode v, asio::error_code& ec)

  283. {

  284.   ::SSL_CTX_set_verify(handle_, v, ::SSL_CTX_get_verify_callback(handle_));

  285. 

  286.   ec = asio::error_code();

  287.   return ec;

  288. }

  289. 

  290. void context::set_verify_depth(int depth)

  291. {

  292.   asio::error_code ec;

  293.   set_verify_depth(depth, ec);

  294.   asio::detail::throw_error(ec, "set_verify_depth");

  295. }

  296. 

  297. asio::error_code context::set_verify_depth(

  298.     int depth, asio::error_code& ec)

  299. {

  300.   ::SSL_CTX_set_verify_depth(handle_, depth);

  301. 

  302.   ec = asio::error_code();

  303.   return ec;

  304. }

  305. 

  306. void context::load_verify_file(const std::string& filename)

  307. {

  308.   asio::error_code ec;

  309.   load_verify_file(filename, ec);

  310.   asio::detail::throw_error(ec, "load_verify_file");

  311. }

  312. 

  313. asio::error_code context::load_verify_file(

  314.     const std::string& filename, asio::error_code& ec)

  315. {

  316.   ::ERR_clear_error();

  317. 

  318.   if (::SSL_CTX_load_verify_locations(handle_, filename.c_str(), 0) != 1)

  319.   {

  320.     ec = asio::error_code(

  321.         static_cast<int>(::ERR_get_error()),

  322.         asio::error::get_ssl_category());

  323.     return ec;

  324.   }

  325. 

  326.   ec = asio::error_code();

  327.   return ec;

  328. }

  329. 

  330. void context::add_certificate_authority(const const_buffer& ca)

  331. {

  332.   asio::error_code ec;

  333.   add_certificate_authority(ca, ec);

  334.   asio::detail::throw_error(ec, "add_certificate_authority");

  335. }

  336. 

  337. asio::error_code context::add_certificate_authority(

  338.     const const_buffer& ca, asio::error_code& ec)

  339. {

  340.   ::ERR_clear_error();

  341. 

  342.   bio_cleanup bio = { make_buffer_bio(ca) };

  343.   if (bio.p)

  344.   {

  345.     x509_cleanup cert = { ::PEM_read_bio_X509(bio.p, 0, 0, 0) };

  346.     if (cert.p)

  347.     {

  348.       if (X509_STORE* store = ::SSL_CTX_get_cert_store(handle_))

  349.       {

  350.         if (::X509_STORE_add_cert(store, cert.p) == 1)

  351.         {

  352.           ec = asio::error_code();

  353.           return ec;

  354.         }

  355.       }

  356.     }

  357.   }

  358. 

  359.   ec = asio::error_code(

  360.       static_cast<int>(::ERR_get_error()),

  361.       asio::error::get_ssl_category());

  362.   return ec;

  363. }

  364. 

  365. void context::set_default_verify_paths()

  366. {

  367.   asio::error_code ec;

  368.   set_default_verify_paths(ec);

  369.   asio::detail::throw_error(ec, "set_default_verify_paths");

  370. }

  371. 

  372. asio::error_code context::set_default_verify_paths(

  373.     asio::error_code& ec)

  374. {

  375.   ::ERR_clear_error();

  376. 

  377.   if (::SSL_CTX_set_default_verify_paths(handle_) != 1)

  378.   {

  379.     ec = asio::error_code(

  380.         static_cast<int>(::ERR_get_error()),

  381.         asio::error::get_ssl_category());

  382.     return ec;

  383.   }

  384. 

  385.   ec = asio::error_code();

  386.   return ec;

  387. }

  388. 

  389. void context::add_verify_path(const std::string& path)

  390. {

  391.   asio::error_code ec;

  392.   add_verify_path(path, ec);

  393.   asio::detail::throw_error(ec, "add_verify_path");

  394. }

  395. 

  396. asio::error_code context::add_verify_path(

  397.     const std::string& path, asio::error_code& ec)

  398. {

  399.   ::ERR_clear_error();

  400. 

  401.   if (::SSL_CTX_load_verify_locations(handle_, 0, path.c_str()) != 1)

  402.   {

  403.     ec = asio::error_code(

  404.         static_cast<int>(::ERR_get_error()),

  405.         asio::error::get_ssl_category());

  406.     return ec;

  407.   }

  408. 

  409.   ec = asio::error_code();

  410.   return ec;

  411. }

  412. 

  413. void context::use_certificate(

  414.     const const_buffer& certificate, file_format format)

  415. {

  416.   asio::error_code ec;

  417.   use_certificate(certificate, format, ec);

  418.   asio::detail::throw_error(ec, "use_certificate");

  419. }

  420. 

  421. asio::error_code context::use_certificate(

  422.     const const_buffer& certificate, file_format format,

  423.     asio::error_code& ec)

  424. {

  425.   ::ERR_clear_error();

  426. 

  427.   if (format == context_base::asn1)

  428.   {

  429.     if (::SSL_CTX_use_certificate_ASN1(handle_,

  430.           static_cast<int>(certificate.size()),

  431.           static_cast<const unsigned char*>(certificate.data())) == 1)

  432.     {

  433.       ec = asio::error_code();

  434.       return ec;

  435.     }

  436.   }

  437.   else if (format == context_base::pem)

  438.   {

  439.     bio_cleanup bio = { make_buffer_bio(certificate) };

  440.     if (bio.p)

  441.     {

  442.       x509_cleanup cert = { ::PEM_read_bio_X509(bio.p, 0, 0, 0) };

  443.       if (cert.p)

  444.       {

  445.         if (::SSL_CTX_use_certificate(handle_, cert.p) == 1)

  446.         {

  447.           ec = asio::error_code();

  448.           return ec;

  449.         }

  450.       }

  451.     }

  452.   }

  453.   else

  454.   {

  455.     ec = asio::error::invalid_argument;

  456.     return ec;

  457.   }

  458. 

  459.   ec = asio::error_code(

  460.       static_cast<int>(::ERR_get_error()),

  461.       asio::error::get_ssl_category());

  462.   return ec;

  463. }

  464. 

  465. void context::use_certificate_file(

  466.     const std::string& filename, file_format format)

  467. {

  468.   asio::error_code ec;

  469.   use_certificate_file(filename, format, ec);

  470.   asio::detail::throw_error(ec, "use_certificate_file");

  471. }

  472. 

  473. asio::error_code context::use_certificate_file(

  474.     const std::string& filename, file_format format,

  475.     asio::error_code& ec)

  476. {

  477.   int file_type;

  478.   switch (format)

  479.   {

  480.   case context_base::asn1:

  481.     file_type = SSL_FILETYPE_ASN1;

  482.     break;

  483.   case context_base::pem:

  484.     file_type = SSL_FILETYPE_PEM;

  485.     break;

  486.   default:

  487.     {

  488.       ec = asio::error::invalid_argument;

  489.       return ec;

  490.     }

  491.   }

  492. 

  493.   ::ERR_clear_error();

  494. 

  495.   if (::SSL_CTX_use_certificate_file(handle_, filename.c_str(), file_type) != 1)

  496.   {

  497.     ec = asio::error_code(

  498.         static_cast<int>(::ERR_get_error()),

  499.         asio::error::get_ssl_category());

  500.     return ec;

  501.   }

  502. 

  503.   ec = asio::error_code();

  504.   return ec;

  505. }

  506. 

  507. void context::use_certificate_chain(const const_buffer& chain)

  508. {

  509.   asio::error_code ec;

  510.   use_certificate_chain(chain, ec);

  511.   asio::detail::throw_error(ec, "use_certificate_chain");

  512. }

  513. 

  514. asio::error_code context::use_certificate_chain(

  515.     const const_buffer& chain, asio::error_code& ec)

  516. {

  517.   ::ERR_clear_error();

  518. 

  519.   bio_cleanup bio = { make_buffer_bio(chain) };

  520.   if (bio.p)

  521.   {

  522.     x509_cleanup cert = {

  523.       ::PEM_read_bio_X509_AUX(bio.p, 0,

  524.           handle_->default_passwd_callback,

  525.           handle_->default_passwd_callback_userdata) };

  526.     if (!cert.p)

  527.     {

  528.       ec = asio::error_code(ERR_R_PEM_LIB,

  529.           asio::error::get_ssl_category());

  530.       return ec;

  531.     }

  532. 

  533.     int result = ::SSL_CTX_use_certificate(handle_, cert.p);

  534.     if (result == 0 || ::ERR_peek_error() != 0)

  535.     {

  536.       ec = asio::error_code(

  537.           static_cast<int>(::ERR_get_error()),

  538.           asio::error::get_ssl_category());

  539.       return ec;

  540.     }

  541. 

  542. #if (OPENSSL_VERSION_NUMBER >= 0x10002000L)

  543.     ::SSL_CTX_clear_chain_certs(handle_);

  544. #else

  545.     if (handle_->extra_certs)

  546.     {

  547.       ::sk_X509_pop_free(handle_->extra_certs, X509_free);

  548.       handle_->extra_certs = 0;

  549.     }

  550. #endif // (OPENSSL_VERSION_NUMBER >= 0x10002000L)

  551. 

  552.     while (X509* cacert = ::PEM_read_bio_X509(bio.p, 0,

  553.           handle_->default_passwd_callback,

  554.           handle_->default_passwd_callback_userdata))

  555.     {

  556.       if (!::SSL_CTX_add_extra_chain_cert(handle_, cacert))

  557.       {

  558.         ec = asio::error_code(

  559.             static_cast<int>(::ERR_get_error()),

  560.             asio::error::get_ssl_category());

  561.         return ec;

  562.       }

  563.     }

  564.   

  565.     result = ::ERR_peek_last_error();

  566.     if ((ERR_GET_LIB(result) == ERR_LIB_PEM)

  567.         && (ERR_GET_REASON(result) == PEM_R_NO_START_LINE))

  568.     {

  569.       ::ERR_clear_error();

  570.       ec = asio::error_code();

  571.       return ec;

  572.     }

  573.   }

  574. 

  575.   ec = asio::error_code(

  576.       static_cast<int>(::ERR_get_error()),

  577.       asio::error::get_ssl_category());

  578.   return ec;

  579. }

  580. 

  581. void context::use_certificate_chain_file(const std::string& filename)

  582. {

  583.   asio::error_code ec;

  584.   use_certificate_chain_file(filename, ec);

  585.   asio::detail::throw_error(ec, "use_certificate_chain_file");

  586. }

  587. 

  588. asio::error_code context::use_certificate_chain_file(

  589.     const std::string& filename, asio::error_code& ec)

  590. {

  591.   ::ERR_clear_error();

  592. 

  593.   if (::SSL_CTX_use_certificate_chain_file(handle_, filename.c_str()) != 1)

  594.   {

  595.     ec = asio::error_code(

  596.         static_cast<int>(::ERR_get_error()),

  597.         asio::error::get_ssl_category());

  598.     return ec;

  599.   }

  600. 

  601.   ec = asio::error_code();

  602.   return ec;

  603. }

  604. 

  605. void context::use_private_key(

  606.     const const_buffer& private_key, context::file_format format)

  607. {

  608.   asio::error_code ec;

  609.   use_private_key(private_key, format, ec);

  610.   asio::detail::throw_error(ec, "use_private_key");

  611. }

  612. 

  613. asio::error_code context::use_private_key(

  614.     const const_buffer& private_key, context::file_format format,

  615.     asio::error_code& ec)

  616. {

  617.   ::ERR_clear_error();

  618. 

  619.   bio_cleanup bio = { make_buffer_bio(private_key) };

  620.   if (bio.p)

  621.   {

  622.     evp_pkey_cleanup evp_private_key = { 0 };

  623.     switch (format)

  624.     {

  625.     case context_base::asn1:

  626.       evp_private_key.p = ::d2i_PrivateKey_bio(bio.p, 0);

  627.       break;

  628.     case context_base::pem:

  629.       evp_private_key.p = ::PEM_read_bio_PrivateKey(

  630.           bio.p, 0, handle_->default_passwd_callback,

  631.           handle_->default_passwd_callback_userdata);

  632.       break;

  633.     default:

  634.       {

  635.         ec = asio::error::invalid_argument;

  636.         return ec;

  637.       }

  638.     }

  639. 

  640.     if (evp_private_key.p)

  641.     {

  642.       if (::SSL_CTX_use_PrivateKey(handle_, evp_private_key.p) == 1)

  643.       {

  644.         ec = asio::error_code();

  645.         return ec;

  646.       }

  647.     }

  648.   }

  649. 

  650.   ec = asio::error_code(

  651.       static_cast<int>(::ERR_get_error()),

  652.       asio::error::get_ssl_category());

  653.   return ec;

  654. }

  655. 

  656. void context::use_private_key_file(

  657.     const std::string& filename, context::file_format format)

  658. {

  659.   asio::error_code ec;

  660.   use_private_key_file(filename, format, ec);

  661.   asio::detail::throw_error(ec, "use_private_key_file");

  662. }

  663. 

  664. void context::use_rsa_private_key(

  665.     const const_buffer& private_key, context::file_format format)

  666. {

  667.   asio::error_code ec;

  668.   use_rsa_private_key(private_key, format, ec);

  669.   asio::detail::throw_error(ec, "use_rsa_private_key");

  670. }

  671. 

  672. asio::error_code context::use_rsa_private_key(

  673.     const const_buffer& private_key, context::file_format format,

  674.     asio::error_code& ec)

  675. {

  676.   ::ERR_clear_error();

  677. 

  678.   bio_cleanup bio = { make_buffer_bio(private_key) };

  679.   if (bio.p)

  680.   {

  681.     rsa_cleanup rsa_private_key = { 0 };

  682.     switch (format)

  683.     {

  684.     case context_base::asn1:

  685.       rsa_private_key.p = ::d2i_RSAPrivateKey_bio(bio.p, 0);

  686.       break;

  687.     case context_base::pem:

  688.       rsa_private_key.p = ::PEM_read_bio_RSAPrivateKey(

  689.           bio.p, 0, handle_->default_passwd_callback,

  690.           handle_->default_passwd_callback_userdata);

  691.       break;

  692.     default:

  693.       {

  694.         ec = asio::error::invalid_argument;

  695.         return ec;

  696.       }

  697.     }

  698. 

  699.     if (rsa_private_key.p)

  700.     {

  701.       if (::SSL_CTX_use_RSAPrivateKey(handle_, rsa_private_key.p) == 1)

  702.       {

  703.         ec = asio::error_code();

  704.         return ec;

  705.       }

  706.     }

  707.   }

  708. 

  709.   ec = asio::error_code(

  710.       static_cast<int>(::ERR_get_error()),

  711.       asio::error::get_ssl_category());

  712.   return ec;

  713. }

  714. 

  715. asio::error_code context::use_private_key_file(

  716.     const std::string& filename, context::file_format format,

  717.     asio::error_code& ec)

  718. {

  719.   int file_type;

  720.   switch (format)

  721.   {

  722.   case context_base::asn1:

  723.     file_type = SSL_FILETYPE_ASN1;

  724.     break;

  725.   case context_base::pem:

  726.     file_type = SSL_FILETYPE_PEM;

  727.     break;

  728.   default:

  729.     {

  730.       ec = asio::error::invalid_argument;

  731.       return ec;

  732.     }

  733.   }

  734. 

  735.   ::ERR_clear_error();

  736. 

  737.   if (::SSL_CTX_use_PrivateKey_file(handle_, filename.c_str(), file_type) != 1)

  738.   {

  739.     ec = asio::error_code(

  740.         static_cast<int>(::ERR_get_error()),

  741.         asio::error::get_ssl_category());

  742.     return ec;

  743.   }

  744. 

  745.   ec = asio::error_code();

  746.   return ec;

  747. }

  748. 

  749. void context::use_rsa_private_key_file(

  750.     const std::string& filename, context::file_format format)

  751. {

  752.   asio::error_code ec;

  753.   use_rsa_private_key_file(filename, format, ec);

  754.   asio::detail::throw_error(ec, "use_rsa_private_key_file");

  755. }

  756. 

  757. asio::error_code context::use_rsa_private_key_file(

  758.     const std::string& filename, context::file_format format,

  759.     asio::error_code& ec)

  760. {

  761.   int file_type;

  762.   switch (format)

  763.   {

  764.   case context_base::asn1:

  765.     file_type = SSL_FILETYPE_ASN1;

  766.     break;

  767.   case context_base::pem:

  768.     file_type = SSL_FILETYPE_PEM;

  769.     break;

  770.   default:

  771.     {

  772.       ec = asio::error::invalid_argument;

  773.       return ec;

  774.     }

  775.   }

  776. 

  777.   ::ERR_clear_error();

  778. 

  779.   if (::SSL_CTX_use_RSAPrivateKey_file(

  780.         handle_, filename.c_str(), file_type) != 1)

  781.   {

  782.     ec = asio::error_code(

  783.         static_cast<int>(::ERR_get_error()),

  784.         asio::error::get_ssl_category());

  785.     return ec;

  786.   }

  787. 

  788.   ec = asio::error_code();

  789.   return ec;

  790. }

  791. 

  792. void context::use_tmp_dh(const const_buffer& dh)

  793. {

  794.   asio::error_code ec;

  795.   use_tmp_dh(dh, ec);

  796.   asio::detail::throw_error(ec, "use_tmp_dh");

  797. }

  798. 

  799. asio::error_code context::use_tmp_dh(

  800.     const const_buffer& dh, asio::error_code& ec)

  801. {

  802.   ::ERR_clear_error();

  803. 

  804.   bio_cleanup bio = { make_buffer_bio(dh) };

  805.   if (bio.p)

  806.   {

  807.     return do_use_tmp_dh(bio.p, ec);

  808.   }

  809. 

  810.   ec = asio::error_code(

  811.       static_cast<int>(::ERR_get_error()),

  812.       asio::error::get_ssl_category());

  813.   return ec;

  814. }

  815. 

  816. void context::use_tmp_dh_file(const std::string& filename)

  817. {

  818.   asio::error_code ec;

  819.   use_tmp_dh_file(filename, ec);

  820.   asio::detail::throw_error(ec, "use_tmp_dh_file");

  821. }

  822. 

  823. asio::error_code context::use_tmp_dh_file(

  824.     const std::string& filename, asio::error_code& ec)

  825. {

  826.   ::ERR_clear_error();

  827. 

  828.   bio_cleanup bio = { ::BIO_new_file(filename.c_str(), "r") };

  829.   if (bio.p)

  830.   {

  831.     return do_use_tmp_dh(bio.p, ec);

  832.   }

  833. 

  834.   ec = asio::error_code(

  835.       static_cast<int>(::ERR_get_error()),

  836.       asio::error::get_ssl_category());

  837.   return ec;

  838. }

  839. 

  840. asio::error_code context::do_use_tmp_dh(

  841.     BIO* bio, asio::error_code& ec)

  842. {

  843.   ::ERR_clear_error();

  844. 

  845.   dh_cleanup dh = { ::PEM_read_bio_DHparams(bio, 0, 0, 0) };

  846.   if (dh.p)

  847.   {

  848.     if (::SSL_CTX_set_tmp_dh(handle_, dh.p) == 1)

  849.     {

  850.       ec = asio::error_code();

  851.       return ec;

  852.     }

  853.   }

  854. 

  855.   ec = asio::error_code(

  856.       static_cast<int>(::ERR_get_error()),

  857.       asio::error::get_ssl_category());

  858.   return ec;

  859. }

  860. 

  861. asio::error_code context::do_set_verify_callback(

  862.     detail::verify_callback_base* callback, asio::error_code& ec)

  863. {

  864.   if (SSL_CTX_get_app_data(handle_))

  865.   {

  866.     delete static_cast<detail::verify_callback_base*>(

  867.         SSL_CTX_get_app_data(handle_));

  868.   }

  869. 

  870.   SSL_CTX_set_app_data(handle_, callback);

  871. 

  872.   ::SSL_CTX_set_verify(handle_,

  873.       ::SSL_CTX_get_verify_mode(handle_),

  874.       &context::verify_callback_function);

  875. 

  876.   ec = asio::error_code();

  877.   return ec;

  878. }

  879. 

  880. int context::verify_callback_function(int preverified, X509_STORE_CTX* ctx)

  881. {

  882.   if (ctx)

  883.   {

  884.     if (SSL* ssl = static_cast<SSL*>(

  885.           ::X509_STORE_CTX_get_ex_data(

  886.             ctx, ::SSL_get_ex_data_X509_STORE_CTX_idx())))

  887.     {

  888.       if (SSL_CTX* handle = ::SSL_get_SSL_CTX(ssl))

  889.       {

  890.         if (SSL_CTX_get_app_data(handle))

  891.         {

  892.           detail::verify_callback_base* callback =

  893.             static_cast<detail::verify_callback_base*>(

  894.                 SSL_CTX_get_app_data(handle));

  895. 

  896.           verify_context verify_ctx(ctx);

  897.           return callback->call(preverified != 0, verify_ctx) ? 1 : 0;

  898.         }

  899.       }

  900.     }

  901.   }

  902. 

  903.   return 0;

  904. }

  905. 

  906. asio::error_code context::do_set_password_callback(

  907.     detail::password_callback_base* callback, asio::error_code& ec)

  908. {

  909.   if (handle_->default_passwd_callback_userdata)

  910.     delete static_cast<detail::password_callback_base*>(

  911.         handle_->default_passwd_callback_userdata);

  912. 

  913.   handle_->default_passwd_callback_userdata = callback;

  914. 

  915.   SSL_CTX_set_default_passwd_cb(handle_, &context::password_callback_function);

  916. 

  917.   ec = asio::error_code();

  918.   return ec;

  919. }

  920. 

  921. int context::password_callback_function(

  922.     char* buf, int size, int purpose, void* data)

  923. {

  924.   using namespace std; // For strncat and strlen.

  925. 

  926.   if (data)

  927.   {

  928.     detail::password_callback_base* callback =

  929.       static_cast<detail::password_callback_base*>(data);

  930. 

  931.     std::string passwd = callback->call(static_cast<std::size_t>(size),

  932.         purpose ? context_base::for_writing : context_base::for_reading);

  933. 

  934. #if defined(ASIO_HAS_SECURE_RTL)

  935.     strcpy_s(buf, size, passwd.c_str());

  936. #else // defined(ASIO_HAS_SECURE_RTL)

  937.     *buf = '\0';

  938.     if (size > 0)

  939.       strncat(buf, passwd.c_str(), size - 1);

  940. #endif // defined(ASIO_HAS_SECURE_RTL)

  941. 

  942.     return static_cast<int>(strlen(buf));

  943.   }

  944. 

  945.   return 0;

  946. }

  947. 

  948. BIO* context::make_buffer_bio(const const_buffer& b)

  949. {

  950.   return ::BIO_new_mem_buf(

  951.       const_cast<void*>(b.data()),

  952.       static_cast<int>(b.size()));

  953. }

  954. 

  955. } // namespace ssl

  956. } // namespace asio

  957. 

  958. #include "asio/detail/pop_options.hpp"

  959. 

  960. #endif // ASIO_SSL_IMPL_CONTEXT_IPP