4

我想通过 SSL 连接发送未经请求的消息。这意味着服务器发送消息不是基于来自客户端的请求，而是因为发生了一些客户端需要知道的事件。

我只是使用来自 boost 站点的 SSL 服务器示例，添加了一个在 10 秒后发送“hello”的计时器，在计时器到期之前一切正常（服务器回显的所有内容），也收到了“hello”，但在那之后应用程序在下次向服务器发送文本时崩溃。

对我来说更奇怪的是，当我禁用 SSL 代码时，使用普通套接字并使用 telnet 执行相同操作，它可以正常工作并继续正常工作！！！

我现在第二次遇到这个问题，我真的不知道为什么会发生这种情况。

以下是我为演示问题而更改的全部来源。在没有 SSL 定义并使用 telnet 的情况下编译它，一切正常，定义 SSL 并使用 openssl，或者来自 boost 网站的客户端 SSL 示例，事情就崩溃了。

#include <cstdlib>
#include <iostream>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>

//#define SSL

typedef boost::asio::ssl::stream<boost::asio::ip::tcp::socket> ssl_socket;

class session
{
public:
  session(boost::asio::io_service& io_service,
      boost::asio::ssl::context& context)
#ifdef SSL  
    : socket_(io_service, context)
#else
    : socket_(io_service)

#endif    
  {
  }

  ssl_socket::lowest_layer_type& socket()
  {
    return socket_.lowest_layer();
  }

  void start()
  {
#ifdef SSL      
    socket_.async_handshake(boost::asio::ssl::stream_base::server,
        boost::bind(&session::handle_handshake, this,
          boost::asio::placeholders::error));
#else
      socket_.async_read_some(boost::asio::buffer(data_, max_length),
          boost::bind(&session::handle_read, this,
            boost::asio::placeholders::error,
            boost::asio::placeholders::bytes_transferred));

      boost::shared_ptr< boost::asio::deadline_timer > timer(new     boost::asio::deadline_timer( socket_.get_io_service() ));
      timer->expires_from_now( boost::posix_time::seconds( 10 ) );
      timer->async_wait( boost::bind( &session::SayHello, this, _1, timer ) );

#endif    
  }

  void handle_handshake(const boost::system::error_code& error)
  {
    if (!error)
    {
      socket_.async_read_some(boost::asio::buffer(data_, max_length),
          boost::bind(&session::handle_read, this,
            boost::asio::placeholders::error,
            boost::asio::placeholders::bytes_transferred));

      boost::shared_ptr< boost::asio::deadline_timer > timer(new     boost::asio::deadline_timer( socket_.get_io_service() ));
      timer->expires_from_now( boost::posix_time::seconds( 10 ) );
      timer->async_wait( boost::bind( &session::SayHello, this, _1, timer ) );

    }
    else
    {
      delete this;
    }
  }

  void SayHello(const boost::system::error_code& error, boost::shared_ptr<     boost::asio::deadline_timer > timer) {
      std::string hello = "hello";

        boost::asio::async_write(socket_,
          boost::asio::buffer(hello, hello.length()),
          boost::bind(&session::handle_write, this,
            boost::asio::placeholders::error));

      timer->expires_from_now( boost::posix_time::seconds( 10 ) );
      timer->async_wait( boost::bind( &session::SayHello, this, _1, timer ) );

  }


  void handle_read(const boost::system::error_code& error,
      size_t bytes_transferred)
  {
    if (!error)
    {
      boost::asio::async_write(socket_,
          boost::asio::buffer(data_, bytes_transferred),
          boost::bind(&session::handle_write, this,
            boost::asio::placeholders::error));
    }
    else
    {
      std::cout << "session::handle_read() -> Delete, ErrorCode: "<< error.value() <<     std::endl;
      delete this;
    }
  }

  void handle_write(const boost::system::error_code& error)
  {
    if (!error)
    {
      socket_.async_read_some(boost::asio::buffer(data_, max_length),
          boost::bind(&session::handle_read, this,
            boost::asio::placeholders::error,
            boost::asio::placeholders::bytes_transferred));
    }
    else
    {
      std::cout << "session::handle_write() -> Delete, ErrorCode: "<< error.value() <<     std::endl;
      delete this;
    }
  }

private:
#ifdef SSL    
  ssl_socket socket_;
#else
  boost::asio::ip::tcp::socket socket_;
#endif  
  enum { max_length = 1024 };
  char data_[max_length];
};

class server
{
public:
  server(boost::asio::io_service& io_service, unsigned short port)
    : io_service_(io_service),
      acceptor_(io_service,
          boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)),
      context_(boost::asio::ssl::context::sslv23)
  {
#ifdef SSL        
    context_.set_options(
        boost::asio::ssl::context::default_workarounds
        | boost::asio::ssl::context::no_sslv2
        | boost::asio::ssl::context::single_dh_use);
    context_.set_password_callback(boost::bind(&server::get_password, this));
    context_.use_certificate_chain_file("server.crt");
    context_.use_private_key_file("server.key", boost::asio::ssl::context::pem);
    context_.use_tmp_dh_file("dh512.pem");
#endif
    start_accept();
  }

  std::string get_password() const
  {
    return "test";
  }

  void start_accept()
  {
    session* new_session = new session(io_service_, context_);
    acceptor_.async_accept(new_session->socket(),
        boost::bind(&server::handle_accept, this, new_session,
          boost::asio::placeholders::error));
  }

  void handle_accept(session* new_session,
      const boost::system::error_code& error)
  {
    if (!error)
    {
      new_session->start();
    }
    else
    {
      delete new_session;
    }

    start_accept();
  }

private:
  boost::asio::io_service& io_service_;
  boost::asio::ip::tcp::acceptor acceptor_;
  boost::asio::ssl::context context_;
};

int main(int argc, char* argv[])
{
  try
  {
    boost::asio::io_service io_service;

    using namespace std; // For atoi.
    server s(io_service, 7777 /*atoi(argv[1])*/);

    io_service.run();
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception: " << e.what() << "\n";
  }

  return 0;
}

我使用 boost 1.49 和 OpenSSL 1.0.0i-fips 2012 年 4 月 19 日。我尝试尽可能多地调查这个问题，上次我遇到这个问题时（几个月前），我收到了一个错误号，我可以追踪到此错误消息：error: decryption failed or bad record mac。

但我不知道出了什么问题以及如何解决这个问题，欢迎提出任何建议。

4

1 回答 1

9

问题是多个并发异步读写。即使使用原始套接字（ glibc 检测到双重释放或损坏），我也能够使该程序崩溃。让我们看看会话开始后会发生什么（在大括号中，我放置了并发计划异步读取和写入的数量）：

  1. 调度异步读取 (1, 0)

  2. （假设数据来了）handle_read被执行，它调度异步写入 (0, 1)

  3. (数据被写入)handle_write被执行，它调度异步读取 (1, 0)

    现在，它可以无限循环超过 1. - 3. 没有任何问题。但随后计时器到期......

  4. （假设没有新数据来自客户端，所以还有一个异步读调度）定时器到期，所以SayHello执行，它调度异步写，仍然没有问题 (1, 1)

  5. （数据SayHello已写入，但客户端仍然没有新数据）handle_write被执行，它调度异步读取 (2, 0)

    现在，我们完成了。如果来自客户端的任何新数据到来，其中一部分可以被一个异步读取读取，另一部分可以被另一个读取。对于原始套接字，它甚至似乎可以工作（尽管可能有 2 个并发写入计划，因此客户端的回显可能看起来很复杂）。对于 SSL，这可能会破坏传入的数据流，这可能就是发生的情况。

如何修复它：

  1. strand在这种情况下将无济于事（它不是并发处理程序执行，而是预定的异步读取和写入）。
  2. SayHello如果异步写入处理程序不执行任何操作（那时不会有并发读取，但仍可能发生并发写入），这还不够。
  3. 如果你真的想要两种不同的写入（回显和计时器），你必须实现某种消息队列来写入，以避免混合来自回显和计时器的写入。
  4. 一般评论：这是一个简单的例子，但使用shared_ptr而不是delete this使用 boost::asio 处理内存分配的更好方法。它将防止丢失错误导致内存泄漏。
于 2012-08-12T11:23:01.693 回答