ceph/src/boost/libs/beast/test/beast/core/detect_ssl.cpp

   1 //
   2 // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
   3 //
   4 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   5 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 //
   7 // Official repository: https://github.com/boostorg/beast
   8 //
   9
  10 // Test that header file is self-contained.
  11 #include <boost/beast/core/detect_ssl.hpp>
  12
  13 #include <boost/beast/_experimental/unit_test/suite.hpp>
  14 #include <boost/beast/_experimental/test/stream.hpp>
  15 #include <boost/beast/_experimental/test/handler.hpp>
  16 #include <boost/beast/core/flat_buffer.hpp>
  17 #include <boost/beast/core/string.hpp>
  18 #include <boost/core/exchange.hpp>
  19 namespace boost {
  20 namespace beast {
  21
  22 class detect_ssl_test : public unit_test::suite
  23 {
  24 public:
  25     void
  26     testDetect()
  27     {
  28         auto const yes =
  29             [](int n, string_view s)
  30             {
  31                 BEAST_EXPECT(detail::is_tls_client_hello(
  32                     net::const_buffer(s.data(), n)));
  33             };
  34
  35         auto const no =
  36             [](int n, string_view s)
  37             {
  38                 BEAST_EXPECT(! detail::is_tls_client_hello(
  39                     net::const_buffer(s.data(), n)));
  40             };
  41
  42         auto const maybe =
  43             [](int n, string_view s)
  44             {
  45                 BEAST_EXPECT(boost::indeterminate(
  46                     detail::is_tls_client_hello(
  47                         net::const_buffer(s.data(), n))));
  48             };
  49
  50         maybe(  0, "\x00\x00\x00\x00\x00\x00\x00\x00\x00");
  51         no   (  1, "\x01\x00\x00\x00\x00\x00\x00\x00\x00");
  52         maybe(  1, "\x16\x00\x00\x00\x00\x00\x00\x00\x00");
  53         maybe(  4, "\x16\x00\x00\x00\x00\x00\x00\x00\x00");
  54         no   (  5, "\x16\x00\x00\x00\x00\x00\x00\x00\x00");
  55         maybe(  5, "\x16\x00\x00\x01\x00\x00\x00\x00\x00");
  56         no   (  8, "\x16\x00\x00\x01\x00\x00\x00\x00\x00");
  57         maybe(  8, "\x16\x00\x00\x01\x00\x01\x00\x00\x00");
  58         no   (  9, "\x16\x00\x00\x01\x00\x01\x01\x00\x00");
  59         yes  (  9, "\x16\x00\x00\x01\x00\x01\x00\x00\x00");
  60     }
  61
  62     void
  63     testRead()
  64     {
  65         net::io_context ioc;
  66
  67         // true
  68
  69         {
  70             error_code ec;
  71             flat_buffer b;
  72             test::stream s1(ioc);
  73             s1.append({"\x16\x00\x00\x01\x00\x01\x00\x00\x00", 9});
  74             auto result = detect_ssl(s1, b, ec);
  75             BEAST_EXPECT(result == true);
  76             BEAST_EXPECTS(! ec, ec.message());
  77         }
  78
  79         // true
  80
  81         {
  82             error_code ec;
  83             flat_buffer b;
  84             test::stream s1(ioc);
  85             auto s2 = test::connect(s1);
  86             s1.append({"\x16\x00\x00\x01\x00\x01\x00\x00\x00", 9});
  87             s2.close();
  88             auto result = detect_ssl(s1, b, ec);
  89             BEAST_EXPECT(result == true);
  90             BEAST_EXPECTS(! ec, ec.message());
  91         }
  92
  93         // false
  94
  95         {
  96             error_code ec;
  97             flat_buffer b;
  98             test::stream s1(ioc);
  99             s1.append({"\x16\x00\x00\x01\x00\x01\x01\x00\x00", 9});
 100             auto result = detect_ssl(s1, b, ec);
 101             BEAST_EXPECT(result == false);
 102             BEAST_EXPECTS(! ec, ec.message());
 103         }
 104
 105         // eof
 106         {
 107             error_code ec;
 108             flat_buffer b;
 109             test::stream s1(ioc);
 110             auto s2 = test::connect(s1);
 111             s1.append({"\x16\x00\x00\x01\x00", 5});
 112             s2.close();
 113             auto result = detect_ssl(s1, b, ec);
 114             BEAST_EXPECT(result == false);
 115             BEAST_EXPECT(ec);
 116         }
 117     }
 118
 119     void
 120     testAsyncRead()
 121     {
 122         net::io_context ioc;
 123
 124         // true
 125
 126         {
 127             flat_buffer b;
 128             test::stream s1(ioc);
 129             s1.append({"\x16\x00\x00\x01\x00\x01\x00\x00\x00", 9});
 130             async_detect_ssl(s1, b, test::success_handler());
 131             test::run(ioc);
 132         }
 133
 134         // true
 135
 136         {
 137             flat_buffer b;
 138             test::stream s1(ioc);
 139             auto s2 = test::connect(s1);
 140             s1.append({"\x16\x00\x00\x01\x00\x01\x00\x00\x00", 9});
 141             s2.close();
 142             async_detect_ssl(s1, b, test::success_handler());
 143             test::run(ioc);
 144         }
 145
 146         // false
 147
 148         {
 149             flat_buffer b;
 150             test::stream s1(ioc);
 151             s1.append({"\x16\x00\x00\x01\x00\x01\x01\x00\x00", 9});
 152             async_detect_ssl(s1, b, test::success_handler());
 153             test::run(ioc);
 154         }
 155
 156         // eof
 157         {
 158             flat_buffer b;
 159             test::stream s1(ioc);
 160             auto s2 = test::connect(s1);
 161             s1.append({"\x16\x00\x00\x01\x00", 5});
 162             s2.close();
 163             async_detect_ssl(s1, b,
 164                 test::fail_handler(net::error::eof));
 165             test::run(ioc);
 166         }
 167     }
 168
 169     void
 170     run() override
 171     {
 172         testDetect();
 173         testRead();
 174         testAsyncRead();
 175     }
 176 };
 177
 178 BEAST_DEFINE_TESTSUITE(beast,core,detect_ssl);
 179
 180 } // beast
 181 } // boost