blob: 8b06c92c83795e7460c503b4810d56c186509dea [file] [log] [blame]
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/socket/fuzzed_socket_factory.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "net/base/address_list.h"
#include "net/base/ip_endpoint.h"
#include "net/base/net_errors.h"
#include "net/base/network_change_notifier.h"
#include "net/log/net_log.h"
#include "net/socket/client_socket_handle.h"
#include "net/socket/connection_attempts.h"
#include "net/socket/fuzzed_socket.h"
#include "net/socket/ssl_client_socket.h"
#include "net/udp/fuzzed_datagram_client_socket.h"
namespace net {
namespace {
// SSLClientSocket implementation that always fails to connect.
class FailingSSLClientSocket : public SSLClientSocket {
public:
FailingSSLClientSocket() {}
~FailingSSLClientSocket() override {}
// Socket implementation:
int Read(IOBuffer* buf,
int buf_len,
const CompletionCallback& callback) override {
NOTREACHED();
return ERR_UNEXPECTED;
}
int Write(IOBuffer* buf,
int buf_len,
const CompletionCallback& callback) override {
NOTREACHED();
return ERR_UNEXPECTED;
}
int SetReceiveBufferSize(int32_t size) override { return OK; }
int SetSendBufferSize(int32_t size) override { return OK; }
// StreamSocket implementation:
int Connect(const CompletionCallback& callback) override {
return ERR_FAILED;
}
void Disconnect() override {}
bool IsConnected() const override { return false; }
bool IsConnectedAndIdle() const override { return false; }
int GetPeerAddress(IPEndPoint* address) const override {
return ERR_SOCKET_NOT_CONNECTED;
}
int GetLocalAddress(IPEndPoint* address) const override {
return ERR_SOCKET_NOT_CONNECTED;
}
const BoundNetLog& NetLog() const override { return net_log_; }
void SetSubresourceSpeculation() override {}
void SetOmniboxSpeculation() override {}
bool WasEverUsed() const override { return false; }
void EnableTCPFastOpenIfSupported() override {}
bool WasNpnNegotiated() const override { return false; }
NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
void GetConnectionAttempts(ConnectionAttempts* out) const override {
out->clear();
}
void ClearConnectionAttempts() override {}
void AddConnectionAttempts(const ConnectionAttempts& attempts) override {}
int64_t GetTotalReceivedBytes() const override { return 0; }
// SSLSocket implementation:
int ExportKeyingMaterial(const base::StringPiece& label,
bool has_context,
const base::StringPiece& context,
unsigned char* out,
unsigned int outlen) override {
NOTREACHED();
return 0;
}
// SSLClientSocket implementation:
void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) override {}
ChannelIDService* GetChannelIDService() const override {
NOTREACHED();
return nullptr;
}
Error GetSignedEKMForTokenBinding(crypto::ECPrivateKey* key,
std::vector<uint8_t>* out) override {
NOTREACHED();
return ERR_UNEXPECTED;
}
crypto::ECPrivateKey* GetChannelIDKey() const override {
NOTREACHED();
return nullptr;
}
private:
BoundNetLog net_log_;
DISALLOW_COPY_AND_ASSIGN(FailingSSLClientSocket);
};
} // namespace
FuzzedSocketFactory::FuzzedSocketFactory(FuzzedDataProvider* data_provider)
: data_provider_(data_provider) {}
FuzzedSocketFactory::~FuzzedSocketFactory() {}
std::unique_ptr<DatagramClientSocket>
FuzzedSocketFactory::CreateDatagramClientSocket(
DatagramSocket::BindType bind_type,
const RandIntCallback& rand_int_cb,
NetLog* net_log,
const NetLog::Source& source) {
return base::WrapUnique(new FuzzedDatagramClientSocket(data_provider_));
}
std::unique_ptr<StreamSocket> FuzzedSocketFactory::CreateTransportClientSocket(
const AddressList& addresses,
std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
NetLog* net_log,
const NetLog::Source& source) {
std::unique_ptr<FuzzedSocket> socket(
new FuzzedSocket(data_provider_, net_log));
socket->set_fuzz_connect_result(true);
// Just use the first address.
socket->set_remote_address(*addresses.begin());
return std::move(socket);
}
std::unique_ptr<SSLClientSocket> FuzzedSocketFactory::CreateSSLClientSocket(
std::unique_ptr<ClientSocketHandle> transport_socket,
const HostPortPair& host_and_port,
const SSLConfig& ssl_config,
const SSLClientSocketContext& context) {
return base::WrapUnique(new FailingSSLClientSocket());
}
void FuzzedSocketFactory::ClearSSLSessionCache() {}
} // namespace net