ldap_mock_server.h

Go to the documentation of this file.

/*
 * Copyright (C) Max Dymond, <cmeister2@gmail.com>, et al.
 *
 * SPDX-License-Identifier: curl
 */

 
#ifndef PROTO_FUZZER_LDAP_MOCK_SERVER_H_
#define PROTO_FUZZER_LDAP_MOCK_SERVER_H_
 
#include <curl/curl.h>
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
#include <string_view>
 
#include "curl_fuzzer.pb.h"
#include "proto_fuzzer/incoming_data_observer.h"
#include "proto_fuzzer/mock_server_base.h"
 
namespace proto_fuzzer {

class LdapMockServer : public MockServerBase, public IncomingDataObserver {
 public:
  LdapMockServer();
 
  ~LdapMockServer() override;
 
  void ObserveState() override;
 
  LdapMockServer(const LdapMockServer&) = delete;
  LdapMockServer& operator=(const LdapMockServer&) = delete;
 
  // Append one transport-decoded client fragment to the BER parser input.
  void ObserveIncomingData(const unsigned char* data, std::size_t size) override;
 
  // Bounded raw capture of complete client LDAPMessages, including envelope.
  const std::string& packet_transcript() const;
 
  // Number of bindRequest messages observed in the most recent drive.
  std::size_t bind_request_count() const;
 
  // Number of searchRequest messages observed.
  std::size_t search_request_count() const;
 
  // Number of root-DSE supportedSASLMechanisms searches observed.
  std::size_t mechanism_search_request_count() const;
 
  // Number of StartTLS ExtendedRequest messages observed.
  std::size_t starttls_request_count() const;
 
  // Number of unbindRequest messages observed during teardown.
  std::size_t unbind_request_count() const;
 
  // Number of server messages written, both scripted and synthesized.
  std::size_t server_message_count() const;
 
  // Number of on_readable chunks forwarded during a search.
  std::size_t scripted_message_count() const;
 
  // Number of searchResDone messages this peer generated itself.
  std::size_t synthesized_done_count() const;
 
  // Number of bind requests answered from initial_response rather than by the
  // synthesized success response.
  std::size_t scripted_bind_response_count() const;
 
 protected:
  curl_socket_t HandleOpenSocket(curlsocktype purpose = CURLSOCKTYPE_IPCXN,
                                 struct curl_sockaddr* address = nullptr) override;
 
  // Construct the transport wrapping curl's socketpair endpoint. The default
  // is a plaintext MockConnection; the LDAPS peer overrides this to return a
  // server-side TLS acceptor over the same socket.
  virtual std::unique_ptr<MockConnection> CreateConnection();
 
  void RunLoop(CURLM* multi, CURL* easy, const curl::fuzzer::proto::Scenario& scenario) override;
 
 private:
  enum class ParseResult {
    kNeedMore,
    kInvalid,
    kComplete,
  };

  struct TlvView {
    unsigned char tag = 0;         
    std::size_t value_offset = 0;  
    std::size_t value_length = 0;  
    std::size_t total_length = 0;  
  };

  struct MessageView {
    unsigned char op_tag = 0;           
    std::uint32_t message_id = 0;       
    std::size_t total_length = 0;       
    bool sasl_mechanism_query = false;  
  };
 
  // Decode one definite-length TLV starting at `offset`.
  static ParseResult ParseTlv(std::string_view bytes, std::size_t offset, TlvView* view);
 
  // Decode an LDAPMessage SEQUENCE { messageID INTEGER, protocolOp ... }.
  static ParseResult ParseMessage(std::string_view bytes, MessageView* message);
 
  // Recognize OpenLDAP's fixed root-DSE SASL mechanism query.
  static bool IsSaslMechanismSearch(std::string_view value);
 
  static void AppendBerLength(std::string* out, std::size_t length);
 
  static void AppendTlv(std::string* out, unsigned char tag, std::string_view value);
 
  static void AppendBerInteger(std::string* out, std::uint32_t value);
 
  // Encode LDAPResult-shaped protocol operations (bindResponse, searchResDone).
  static void BuildResultMessage(std::uint32_t message_id, unsigned char op_tag, int result_code, std::string* out);
 
  // Encode a root-DSE entry advertising the bounded PLAIN SASL mechanism.
  static void BuildSaslMechanismsEntry(std::uint32_t message_id, std::string* out);
 
  // Replace the envelope messageID while preserving the rest of the message.
  static bool RewriteMessageId(std::string_view message, std::uint32_t message_id, std::string* out);
 
  static bool MessageOpTag(std::string_view message, unsigned char* op_tag);
 
  void ResetForScenario(const curl::fuzzer::proto::Scenario& scenario);
 
  static void ApplyScriptBackpressure(MockConnection* connection, const curl::fuzzer::proto::Connection& script);
 
  bool ServiceClientConnection();
 
  void HandleClientMessage(const MessageView& message);
 
  void HandleBindRequest(std::uint32_t message_id);
 
  void HandleSearchRequest(std::uint32_t message_id);
 
  void HandleMechanismSearchRequest(std::uint32_t message_id);
 
  void HandleStartTlsRequest(std::uint32_t message_id);
 
  bool ReleaseNextServerChunk();
 
  bool FinishSearchIfReady();
 
  bool WriteServerBytes(std::string_view bytes);
 
  static void CapturePrefix(std::string_view source, std::size_t limit, std::string* destination);
 
  void FinishConnections();

  static constexpr std::size_t kMaxClientMessageBytes = 64 * 1024;

  static constexpr std::size_t kMaxCapturedMessageBytes = 64 * 1024;

  static constexpr int kMaxMessagesPerService = 16;

  const curl::fuzzer::proto::Scenario* scenario_;
  std::size_t server_chunk_count_;
  std::size_t next_server_chunk_;
  std::size_t bind_request_count_;
  std::size_t search_request_count_;
  std::size_t mechanism_search_request_count_;
  std::size_t starttls_request_count_;
  std::size_t unbind_request_count_;
  std::size_t server_message_count_;
  std::size_t scripted_message_count_;
  std::size_t synthesized_done_count_;
  std::size_t scripted_bind_response_count_;
  std::string pending_client_bytes_;
  std::string packet_transcript_;
  std::uint32_t search_message_id_;
  bool search_active_;
  bool search_done_sent_;
  bool scripted_bind_consumed_;
  bool release_script_chunks_;
  bool peer_closed_;
  bool protocol_error_;
  bool socket_opened_;
};
 
}  // namespace proto_fuzzer
 
#endif  // PROTO_FUZZER_LDAP_MOCK_SERVER_H_