PeekingPeerConnector.cc
Go to the documentation of this file.
1 /*
2  * Copyright (C) 1996-2017 The Squid Software Foundation and contributors
3  *
4  * Squid software is distributed under GPLv2+ license and includes
5  * contributions from numerous individuals and organizations.
6  * Please see the COPYING and CONTRIBUTORS files for details.
7  */
8 
9 /* DEBUG: section 83 SSL-Bump Server/Peer negotiation */
10 
11 #include "squid.h"
12 #include "acl/FilledChecklist.h"
13 #include "client_side.h"
14 #include "errorpage.h"
15 #include "fde.h"
16 #include "http/Stream.h"
17 #include "HttpRequest.h"
19 #include "SquidConfig.h"
20 #include "ssl/bio.h"
22 #include "ssl/ServerBump.h"
23 
24 CBDATA_NAMESPACED_CLASS_INIT(Ssl, PeekingPeerConnector);
25 
27 
28 void
30 {
32  // Use job calls to add done() checks and other job logic/protections.
34 }
35 
36 void
38 {
39  const Ssl::BumpMode finalAction = answer.allowed() ?
40  static_cast<Ssl::BumpMode>(answer.kind):
41  checkForPeekAndSpliceGuess();
42  checkForPeekAndSpliceMatched(finalAction);
43 }
44 
45 void
47 {
48  // Mark Step3 of bumping
49  if (request->clientConnectionManager.valid()) {
50  if (Ssl::ServerBump *serverBump = request->clientConnectionManager->serverBump()) {
51  serverBump->step = Ssl::bumpStep3;
52  }
53  }
54 
55  handleServerCertificate();
56 
57  ACLFilledChecklist *acl_checklist = new ACLFilledChecklist(
58  ::Config.accessList.ssl_bump,
59  request.getRaw(), NULL);
60  acl_checklist->al = al;
66  Security::SessionPointer session(fd_table[serverConn->fd].ssl);
67  BIO *b = SSL_get_rbio(session.get());
68  Ssl::ServerBio *srvBio = static_cast<Ssl::ServerBio *>(BIO_get_data(b));
69  if (!srvBio->canSplice())
71  if (!srvBio->canBump())
74 }
75 
76 void
78 {
79  Security::SessionPointer session(fd_table[serverConn->fd].ssl);
80  BIO *b = SSL_get_rbio(session.get());
81  Ssl::ServerBio *srvBio = static_cast<Ssl::ServerBio *>(BIO_get_data(b));
82  debugs(83,5, "Will check for peek and splice on FD " << serverConn->fd);
83 
84  Ssl::BumpMode finalAction = action;
85  Must(finalAction == Ssl::bumpSplice || finalAction == Ssl::bumpBump || finalAction == Ssl::bumpTerminate);
86  // Record final decision
87  if (request->clientConnectionManager.valid()) {
88  request->clientConnectionManager->sslBumpMode = finalAction;
89  request->clientConnectionManager->serverBump()->act.step3 = finalAction;
90  }
91  al->ssl.bumpMode = finalAction;
92 
93  if (finalAction == Ssl::bumpTerminate) {
94  serverConn->close();
95  clientConn->close();
96  } else if (finalAction != Ssl::bumpSplice) {
97  //Allow write, proceed with the connection
98  srvBio->holdWrite(false);
99  srvBio->recordInput(false);
100  debugs(83,5, "Retry the fwdNegotiateSSL on FD " << serverConn->fd);
102  } else {
103  splice = true;
104  // Ssl Negotiation stops here. Last SSL checks for valid certificates
105  // and if done, switch to tunnel mode
106  if (sslFinalized()) {
107  debugs(83,5, "Abort NegotiateSSL on FD " << serverConn->fd << " and splice the connection");
108  callBack();
109  }
110  }
111 }
112 
115 {
116  if (const ConnStateData *csd = request->clientConnectionManager.valid()) {
117  const Ssl::BumpMode currentMode = csd->sslBumpMode;
118  if (currentMode == Ssl::bumpStare) {
119  debugs(83,5, "default to bumping after staring");
120  return Ssl::bumpBump;
121  }
122  debugs(83,5, "default to splicing after " << currentMode);
123  } else {
124  debugs(83,3, "default to splicing due to missing info");
125  }
126 
127  return Ssl::bumpSplice;
128 }
129 
132 {
134 }
135 
136 bool
138 {
139  if (!Security::PeerConnector::initialize(serverSession))
140  return false;
141 
142  if (ConnStateData *csd = request->clientConnectionManager.valid()) {
143 
144  // client connection is required in the case we need to splice
145  // or terminate client and server connections
146  assert(clientConn != NULL);
147  SBuf *hostName = NULL;
148 
149  //Enable Status_request TLS extension, required to bump some clients
150  SSL_set_tlsext_status_type(serverSession.get(), TLSEXT_STATUSTYPE_ocsp);
151 
152  const Security::TlsDetails::Pointer details = csd->tlsParser.details;
153  if (details && !details->serverName.isEmpty())
154  hostName = new SBuf(details->serverName);
155 
156  if (!hostName) {
157  // While we are peeking at the certificate, we may not know the server
158  // name that the client will request (after interception or CONNECT)
159  // unless it was the CONNECT request with a user-typed address.
160  const bool isConnectRequest = !csd->port->flags.isIntercepted();
161  if (!request->flags.sslPeek || isConnectRequest)
162  hostName = new SBuf(request->url.host());
163  }
164 
165  if (hostName)
166  SSL_set_ex_data(serverSession.get(), ssl_ex_index_server, (void*)hostName);
167 
168  Must(!csd->serverBump() || csd->serverBump()->step <= Ssl::bumpStep2);
169  if (csd->sslBumpMode == Ssl::bumpPeek || csd->sslBumpMode == Ssl::bumpStare) {
170  auto clientSession = fd_table[clientConn->fd].ssl.get();
171  Must(clientSession);
172  BIO *bc = SSL_get_rbio(clientSession);
173  Ssl::ClientBio *cltBio = static_cast<Ssl::ClientBio *>(BIO_get_data(bc));
174  Must(cltBio);
175  if (details && details->tlsVersion.protocol != AnyP::PROTO_NONE)
176  applyTlsDetailsToSSL(serverSession.get(), details, csd->sslBumpMode);
177 
178  BIO *b = SSL_get_rbio(serverSession.get());
179  Ssl::ServerBio *srvBio = static_cast<Ssl::ServerBio *>(BIO_get_data(b));
180  Must(srvBio);
181  // inherit client features such as TLS version and SNI
182  srvBio->setClientFeatures(details, cltBio->rBufData());
183  srvBio->recordInput(true);
184  srvBio->mode(csd->sslBumpMode);
185  } else {
186  // Set client SSL options
187  SSL_set_options(serverSession.get(), ::Security::ProxyOutgoingConfig.parsedOptions);
188 
189  // Use SNI TLS extension only when we connect directly
190  // to the origin server and we know the server host name.
191  const char *sniServer = NULL;
192  const bool redirected = request->flags.redirected && ::Config.onoff.redir_rewrites_host;
193  if (!hostName || redirected)
194  sniServer = !request->url.hostIsNumeric() ? request->url.host() : NULL;
195  else
196  sniServer = hostName->c_str();
197 
198  if (sniServer)
199  Ssl::setClientSNI(serverSession.get(), sniServer);
200  }
201 
202  if (Ssl::ServerBump *serverBump = csd->serverBump()) {
203  serverBump->attachServerSession(serverSession);
204  // store peeked cert to check SQUID_X509_V_ERR_CERT_CHANGE
205  if (X509 *peeked_cert = serverBump->serverCert.get()) {
206  X509_up_ref(peeked_cert);
207  SSL_set_ex_data(serverSession.get(), ssl_ex_index_ssl_peeked_cert, peeked_cert);
208  }
209  }
210  }
211 
212  return true;
213 }
214 
215 void
217 {
218  // Check the list error with
219  if (!request->clientConnectionManager.valid() || !fd_table[serverConnection()->fd].ssl)
220  return;
221 
222  // remember the server certificate from the ErrorDetail object
223  if (Ssl::ServerBump *serverBump = request->clientConnectionManager->serverBump()) {
224  if (!serverBump->serverCert.get()) {
225  // remember the server certificate from the ErrorDetail object
226  if (error && error->detail && error->detail->peerCert())
227  serverBump->serverCert.resetAndLock(error->detail->peerCert());
228  else {
229  handleServerCertificate();
230  }
231  }
232 
233  if (error) {
234  // For intercepted connections, set the host name to the server
235  // certificate CN. Otherwise, we just hope that CONNECT is using
236  // a user-entered address (a host name or a user-entered IP).
237  const bool isConnectRequest = !request->clientConnectionManager->port->flags.isIntercepted();
238  if (request->flags.sslPeek && !isConnectRequest) {
239  if (X509 *srvX509 = serverBump->serverCert.get()) {
240  if (const char *name = Ssl::CommonHostName(srvX509)) {
241  request->url.host(name);
242  debugs(83, 3, "reset request host: " << name);
243  }
244  }
245  }
246  }
247  }
248 
249  if (!error) {
250  serverCertificateVerified();
251  if (splice) {
252  switchToTunnel(request.getRaw(), clientConn, serverConn);
253  tunnelInsteadOfNegotiating();
254  }
255  }
256 }
257 
258 void
260 {
261  const int fd = serverConnection()->fd;
262  Security::SessionPointer session(fd_table[fd].ssl);
263  BIO *b = SSL_get_rbio(session.get());
264  Ssl::ServerBio *srvBio = static_cast<Ssl::ServerBio *>(BIO_get_data(b));
265 
266  if ((srvBio->bumpMode() == Ssl::bumpPeek || srvBio->bumpMode() == Ssl::bumpStare) && srvBio->holdWrite()) {
267  debugs(81, 3, "hold write on SSL connection on FD " << fd);
268  checkForPeekAndSplice();
269  return;
270  }
271 
273 }
274 
275 void
276 Ssl::PeekingPeerConnector::noteNegotiationError(const int result, const int ssl_error, const int ssl_lib_error)
277 {
278  const int fd = serverConnection()->fd;
279  Security::SessionPointer session(fd_table[fd].ssl);
280  BIO *b = SSL_get_rbio(session.get());
281  Ssl::ServerBio *srvBio = static_cast<Ssl::ServerBio *>(BIO_get_data(b));
282 
283  // In Peek mode, the ClientHello message sent to the server. If the
284  // server resuming a previous (spliced) SSL session with the client,
285  // then probably we are here because local SSL object does not know
286  // anything about the session being resumed.
287  //
288  if (srvBio->bumpMode() == Ssl::bumpPeek && (resumingSession = srvBio->resumingSession())) {
289  // we currently splice all resumed sessions unconditionally
290  if (const bool spliceResumed = true) {
291  bypassCertValidator();
292  checkForPeekAndSpliceMatched(Ssl::bumpSplice);
293  return;
294  } // else fall through to find a matching ssl_bump action (with limited info)
295  }
296 
297  // If we are in peek-and-splice mode and still we did not write to
298  // server yet, try to see if we should splice.
299  // In this case the connection can be saved.
300  // If the checklist decision is do not splice a new error will
301  // occur in the next SSL_connect call, and we will fail again.
302  // Abort on certificate validation errors to avoid splicing and
303  // thus hiding them.
304  // Abort if no certificate found probably because of malformed or
305  // unsupported server Hello message (TODO: make configurable).
306  if (!SSL_get_ex_data(session.get(), ssl_ex_index_ssl_error_detail) &&
307  (srvBio->bumpMode() == Ssl::bumpPeek || srvBio->bumpMode() == Ssl::bumpStare) && srvBio->holdWrite()) {
308  Security::CertPointer serverCert(SSL_get_peer_certificate(session.get()));
309  if (serverCert) {
310  debugs(81, 3, "Error (" << Security::ErrorString(ssl_lib_error) << ") but, hold write on SSL connection on FD " << fd);
311  checkForPeekAndSplice();
312  return;
313  }
314  }
315 
316  // else call parent noteNegotiationError to produce an error page
317  Security::PeerConnector::noteNegotiationError(result, ssl_error, ssl_lib_error);
318 }
319 
320 void
322 {
323  if (serverCertificateHandled)
324  return;
325 
326  if (ConnStateData *csd = request->clientConnectionManager.valid()) {
327  const int fd = serverConnection()->fd;
328  Security::SessionPointer session(fd_table[fd].ssl);
329  Security::CertPointer serverCert(SSL_get_peer_certificate(session.get()));
330  if (!serverCert)
331  return;
332 
333  serverCertificateHandled = true;
334 
335  // remember the server certificate for later use
336  if (Ssl::ServerBump *serverBump = csd->serverBump()) {
337  serverBump->serverCert = std::move(serverCert);
338  }
339  }
340 }
341 
342 void
344 {
345  if (ConnStateData *csd = request->clientConnectionManager.valid()) {
346  Security::CertPointer serverCert;
347  if(Ssl::ServerBump *serverBump = csd->serverBump())
348  serverCert.resetAndLock(serverBump->serverCert.get());
349  else {
350  const int fd = serverConnection()->fd;
351  Security::SessionPointer session(fd_table[fd].ssl);
352  serverCert.resetWithoutLocking(SSL_get_peer_certificate(session.get()));
353  }
354  if (serverCert) {
355  csd->resetSslCommonName(Ssl::CommonHostName(serverCert.get()));
356  debugs(83, 5, "HTTPS server CN: " << csd->sslCommonName() <<
357  " bumped: " << *serverConnection());
358  }
359  }
360 }
361 
362 void
364 {
365  Must(callback != NULL);
366  CbDialer *dialer = dynamic_cast<CbDialer*>(callback->getDialer());
367  Must(dialer);
368  dialer->answer().tunneled = true;
369  debugs(83, 5, "The SSL negotiation with server aborted");
370 }
371 
int ssl_ex_index_ssl_peeked_cert
void nonBlockingCheck(ACLCB *callback, void *callback_data)
Definition: Checklist.cc:238
void tunnelInsteadOfNegotiating()
Inform caller class that the SSL negotiation aborted.
#define fd_table
Definition: fde.h:157
#define assert(EX)
Definition: assert.h:17
void const char HLPCB * callback
Definition: stub_helper.cc:16
static void cbCheckForPeekAndSpliceDone(allow_t answer, void *data)
A wrapper function for checkForPeekAndSpliceDone for use with acl.
int ssl_ex_index_server
bool setClientSNI(SSL *ssl, const char *fqdn)
Definition: support.cc:927
const SBuf & rBufData()
The buffered input data.
Definition: bio.h:58
virtual void noteNegotiationDone(ErrorState *error)
Definition: Acl.h:113
Definition: SBuf.h:87
struct _request * request(char *urlin)
Definition: tcp-banger2.c:291
void error(char *format,...)
void banAction(const allow_t &action)
add action to the list of banned actions
Definition: Checklist.cc:402
Security::ParsedOptions parsedOptions
parsed value of sslOptions
Definition: PeerOptions.h:81
AccessLogEntry::Pointer al
info for the future access.log, and external ACL
Security::ContextPointer sslContext
Definition: SquidConfig.h:509
void switchToTunnel(HttpRequest *request, Comm::ConnectionPointer &clientConn, Comm::ConnectionPointer &srvConn)
Definition: tunnel.cc:1333
X509 * peerCert()
the peer certificate
Definition: ErrorDetail.h:57
A PeerConnector for HTTP origin servers. Capable of SslBumping.
struct SquidConfig::@123 ssl_client
virtual void noteWantWrite()
virtual Security::ContextPointer getTlsContext()
void const char HLPCB void * data
Definition: stub_helper.cc:16
#define debugs(SECTION, LEVEL, CONTENT)
Definition: Debug.h:123
int ssl_ex_index_ssl_error_detail
const char * CommonHostName(X509 *x509)
Definition: gadgets.cc:913
virtual bool initialize(Security::SessionPointer &)
PeerOptions ProxyOutgoingConfig
configuration options for DIRECT server access
Definition: PeerOptions.cc:22
int kind
which custom access list verb matched
Definition: Acl.h:153
Ssl::BumpMode checkForPeekAndSpliceGuess() const
Guesses the final bumping decision when no ssl_bump rules match.
std::shared_ptr< SSL_CTX > ContextPointer
Definition: Context.h:28
bool allowed() const
Definition: Acl.h:141
void checkForPeekAndSpliceDone(allow_t answer)
Callback function for ssl_bump acl check in step3 SSL bump step.
virtual Security::EncryptorAnswer & answer()=0
gives PeerConnector access to the in-dialer answer
#define CallJobHere1(debugSection, debugLevel, job, Class, method, arg1)
Definition: AsyncJobCalls.h:62
bool tunneled
whether we spliced the connections instead of negotiating encryption
bool action(int fd, size_t metasize, const char *fn, const char *url, const SquidMetaList &meta)
Definition: purge.cc:311
#define Must(cond)
Definition: TextException.h:89
CBDATA_NAMESPACED_CLASS_INIT(Ssl, PeekingPeerConnector)
void applyTlsDetailsToSSL(SSL *ssl, Security::TlsDetails::Pointer const &details, Ssl::BumpMode bumpMode)
Definition: bio.cc:686
char * url
Definition: tcp-banger2.c:114
void Comm::ConnectionPointer & clientConn
Definition: stub_tunnel.cc:19
virtual void noteNegotiationError(const int result, const int ssl_error, const int ssl_lib_error)
Callback dialer API to allow PeerConnector to set the answer.
Definition: PeerConnector.h:69
virtual bool initialize(Security::SessionPointer &)
void * BIO_get_data(BIO *table)
Definition: bio.h:207
BumpMode
Definition: support.h:125
void checkForPeekAndSpliceMatched(const Ssl::BumpMode finalMode)
Handles the final bumping decision.
virtual void noteNegotiationError(const int result, const int ssl_error, const int ssl_lib_error)
Ssl::ErrorDetail * detail
Definition: errorpage.h:170
const char * ErrorString(const ErrorCode code)
Definition: forward.h:121
class SquidConfig Config
Definition: SquidConfig.cc:12
#define NULL
Definition: types.h:166
std::shared_ptr< SSL > SessionPointer
Definition: Session.h:41

 

Introduction

Documentation

Support

Miscellaneous

Web Site Translations

Mirrors