| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/socket/ssl_session_cache_openssl.h" | |
| 6 | |
| 7 #include <list> | |
| 8 #include <map> | |
| 9 | |
| 10 #include <openssl/rand.h> | |
| 11 #include <openssl/ssl.h> | |
| 12 | |
| 13 #include "base/containers/hash_tables.h" | |
| 14 #include "base/lazy_instance.h" | |
| 15 #include "base/logging.h" | |
| 16 #include "base/synchronization/lock.h" | |
| 17 | |
| 18 namespace net { | |
| 19 | |
| 20 namespace { | |
| 21 | |
| 22 // A helper class to lazily create a new EX_DATA index to map SSL_CTX handles | |
| 23 // to their corresponding SSLSessionCacheOpenSSLImpl object. | |
| 24 class SSLContextExIndex { | |
| 25 public: | |
| 26 SSLContextExIndex() { | |
| 27 context_index_ = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL, NULL); | |
| 28 DCHECK_NE(-1, context_index_); | |
| 29 session_index_ = SSL_SESSION_get_ex_new_index(0, NULL, NULL, NULL, NULL); | |
| 30 DCHECK_NE(-1, session_index_); | |
| 31 } | |
| 32 | |
| 33 int context_index() const { return context_index_; } | |
| 34 int session_index() const { return session_index_; } | |
| 35 | |
| 36 private: | |
| 37 int context_index_; | |
| 38 int session_index_; | |
| 39 }; | |
| 40 | |
| 41 // static | |
| 42 base::LazyInstance<SSLContextExIndex>::Leaky s_ssl_context_ex_instance = | |
| 43 LAZY_INSTANCE_INITIALIZER; | |
| 44 | |
| 45 // Retrieve the global EX_DATA index, created lazily on first call, to | |
| 46 // be used with SSL_CTX_set_ex_data() and SSL_CTX_get_ex_data(). | |
| 47 static int GetSSLContextExIndex() { | |
| 48 return s_ssl_context_ex_instance.Get().context_index(); | |
| 49 } | |
| 50 | |
| 51 // Retrieve the global EX_DATA index, created lazily on first call, to | |
| 52 // be used with SSL_SESSION_set_ex_data() and SSL_SESSION_get_ex_data(). | |
| 53 static int GetSSLSessionExIndex() { | |
| 54 return s_ssl_context_ex_instance.Get().session_index(); | |
| 55 } | |
| 56 | |
| 57 // Helper struct used to store session IDs in a SessionIdIndex container | |
| 58 // (see definition below). To save memory each entry only holds a pointer | |
| 59 // to the session ID buffer, which must outlive the entry itself. On the | |
| 60 // other hand, a hash is included to minimize the number of hashing | |
| 61 // computations during cache operations. | |
| 62 struct SessionId { | |
| 63 SessionId(const unsigned char* a_id, unsigned a_id_len) | |
| 64 : id(a_id), id_len(a_id_len), hash(ComputeHash(a_id, a_id_len)) {} | |
| 65 | |
| 66 explicit SessionId(const SessionId& other) | |
| 67 : id(other.id), id_len(other.id_len), hash(other.hash) {} | |
| 68 | |
| 69 explicit SessionId(SSL_SESSION* session) | |
| 70 : id(session->session_id), | |
| 71 id_len(session->session_id_length), | |
| 72 hash(ComputeHash(session->session_id, session->session_id_length)) {} | |
| 73 | |
| 74 bool operator==(const SessionId& other) const { | |
| 75 return hash == other.hash && id_len == other.id_len && | |
| 76 !memcmp(id, other.id, id_len); | |
| 77 } | |
| 78 | |
| 79 const unsigned char* id; | |
| 80 unsigned id_len; | |
| 81 size_t hash; | |
| 82 | |
| 83 private: | |
| 84 // Session ID are random strings of bytes. This happens to compute the same | |
| 85 // value as std::hash<std::string> without the extra string copy. See | |
| 86 // base/containers/hash_tables.h. Other hashing computations are possible, | |
| 87 // this one is just simple enough to do the job. | |
| 88 size_t ComputeHash(const unsigned char* id, unsigned id_len) { | |
| 89 size_t result = 0; | |
| 90 for (unsigned n = 0; n < id_len; ++n) { | |
| 91 result = (result * 131) + id[n]; | |
| 92 } | |
| 93 return result; | |
| 94 } | |
| 95 }; | |
| 96 | |
| 97 } // namespace | |
| 98 | |
| 99 } // namespace net | |
| 100 | |
| 101 namespace BASE_HASH_NAMESPACE { | |
| 102 | |
| 103 template <> | |
| 104 struct hash<net::SessionId> { | |
| 105 std::size_t operator()(const net::SessionId& entry) const { | |
| 106 return entry.hash; | |
| 107 } | |
| 108 }; | |
| 109 | |
| 110 } // namespace BASE_HASH_NAMESPACE | |
| 111 | |
| 112 namespace net { | |
| 113 | |
| 114 // Implementation of the real SSLSessionCache. | |
| 115 // | |
| 116 // The implementation is inspired by base::MRUCache, except that the deletor | |
| 117 // also needs to remove the entry from other containers. In a nutshell, this | |
| 118 // uses several basic containers: | |
| 119 // | |
| 120 // |ordering_| is a doubly-linked list of SSL_SESSION handles, ordered in | |
| 121 // MRU order. | |
| 122 // | |
| 123 // |key_index_| is a hash table mapping unique cache keys (e.g. host/port | |
| 124 // values) to a single iterator of |ordering_|. It is used to efficiently | |
| 125 // find the cached session associated with a given key. | |
| 126 // | |
| 127 // |id_index_| is a hash table mapping SessionId values to iterators | |
| 128 // of |key_index_|. If is used to efficiently remove sessions from the cache, | |
| 129 // as well as check for the existence of a session ID value in the cache. | |
| 130 // | |
| 131 // SSL_SESSION objects are reference-counted, and owned by the cache. This | |
| 132 // means that their reference count is incremented when they are added, and | |
| 133 // decremented when they are removed. | |
| 134 // | |
| 135 // Assuming an average key size of 100 characters, each node requires the | |
| 136 // following memory usage on 32-bit Android, when linked against STLport: | |
| 137 // | |
| 138 // 12 (ordering_ node, including SSL_SESSION handle) | |
| 139 // 100 (key characters) | |
| 140 // + 24 (std::string header/minimum size) | |
| 141 // + 8 (key_index_ node, excluding the 2 lines above for the key). | |
| 142 // + 20 (id_index_ node) | |
| 143 // -------- | |
| 144 // 164 bytes/node | |
| 145 // | |
| 146 // Hence, 41 KiB for a full cache with a maximum of 1024 entries, excluding | |
| 147 // the size of SSL_SESSION objects and heap fragmentation. | |
| 148 // | |
| 149 | |
| 150 class SSLSessionCacheOpenSSLImpl { | |
| 151 public: | |
| 152 // Construct new instance. This registers various hooks into the SSL_CTX | |
| 153 // context |ctx|. OpenSSL will call back during SSL connection | |
| 154 // operations. |key_func| is used to map a SSL handle to a unique cache | |
| 155 // string, according to the client's preferences. | |
| 156 SSLSessionCacheOpenSSLImpl(SSL_CTX* ctx, | |
| 157 const SSLSessionCacheOpenSSL::Config& config) | |
| 158 : ctx_(ctx), config_(config), expiration_check_(0) { | |
| 159 DCHECK(ctx); | |
| 160 | |
| 161 // NO_INTERNAL_STORE disables OpenSSL's builtin cache, and | |
| 162 // NO_AUTO_CLEAR disables the call to SSL_CTX_flush_sessions | |
| 163 // every 256 connections (this number is hard-coded in the library | |
| 164 // and can't be changed). | |
| 165 SSL_CTX_set_session_cache_mode(ctx_, | |
| 166 SSL_SESS_CACHE_CLIENT | | |
| 167 SSL_SESS_CACHE_NO_INTERNAL_STORE | | |
| 168 SSL_SESS_CACHE_NO_AUTO_CLEAR); | |
| 169 | |
| 170 SSL_CTX_sess_set_new_cb(ctx_, NewSessionCallbackStatic); | |
| 171 SSL_CTX_sess_set_remove_cb(ctx_, RemoveSessionCallbackStatic); | |
| 172 SSL_CTX_set_generate_session_id(ctx_, GenerateSessionIdStatic); | |
| 173 SSL_CTX_set_timeout(ctx_, config_.timeout_seconds); | |
| 174 | |
| 175 SSL_CTX_set_ex_data(ctx_, GetSSLContextExIndex(), this); | |
| 176 } | |
| 177 | |
| 178 // Destroy this instance. Must happen before |ctx_| is destroyed. | |
| 179 ~SSLSessionCacheOpenSSLImpl() { | |
| 180 Flush(); | |
| 181 SSL_CTX_set_ex_data(ctx_, GetSSLContextExIndex(), NULL); | |
| 182 SSL_CTX_sess_set_new_cb(ctx_, NULL); | |
| 183 SSL_CTX_sess_set_remove_cb(ctx_, NULL); | |
| 184 SSL_CTX_set_generate_session_id(ctx_, NULL); | |
| 185 } | |
| 186 | |
| 187 // Return the number of items in this cache. | |
| 188 size_t size() const { return key_index_.size(); } | |
| 189 | |
| 190 // Retrieve the cache key from |ssl| and look for a corresponding | |
| 191 // cached session ID. If one is found, call SSL_set_session() to associate | |
| 192 // it with the |ssl| connection. | |
| 193 // | |
| 194 // Will also check for expired sessions every |expiration_check_count| | |
| 195 // calls. | |
| 196 // | |
| 197 // Return true if a cached session ID was found, false otherwise. | |
| 198 bool SetSSLSession(SSL* ssl) { | |
| 199 std::string cache_key = config_.key_func(ssl); | |
| 200 if (cache_key.empty()) | |
| 201 return false; | |
| 202 | |
| 203 return SetSSLSessionWithKey(ssl, cache_key); | |
| 204 } | |
| 205 | |
| 206 // Variant of SetSSLSession to be used when the client already has computed | |
| 207 // the cache key. Avoid a call to the configuration's |key_func| function. | |
| 208 bool SetSSLSessionWithKey(SSL* ssl, const std::string& cache_key) { | |
| 209 base::AutoLock locked(lock_); | |
| 210 | |
| 211 DCHECK_EQ(config_.key_func(ssl), cache_key); | |
| 212 | |
| 213 if (++expiration_check_ >= config_.expiration_check_count) { | |
| 214 expiration_check_ = 0; | |
| 215 FlushExpiredSessionsLocked(); | |
| 216 } | |
| 217 | |
| 218 KeyIndex::iterator it = key_index_.find(cache_key); | |
| 219 if (it == key_index_.end()) | |
| 220 return false; | |
| 221 | |
| 222 SSL_SESSION* session = *it->second; | |
| 223 DCHECK(session); | |
| 224 | |
| 225 DVLOG(2) << "Lookup session: " << session << " for " << cache_key; | |
| 226 | |
| 227 void* session_is_good = | |
| 228 SSL_SESSION_get_ex_data(session, GetSSLSessionExIndex()); | |
| 229 if (!session_is_good) | |
| 230 return false; // Session has not yet been marked good. Treat as a miss. | |
| 231 | |
| 232 // Move to front of MRU list. | |
| 233 ordering_.push_front(session); | |
| 234 ordering_.erase(it->second); | |
| 235 it->second = ordering_.begin(); | |
| 236 | |
| 237 return SSL_set_session(ssl, session) == 1; | |
| 238 } | |
| 239 | |
| 240 void MarkSSLSessionAsGood(SSL* ssl) { | |
| 241 SSL_SESSION* session = SSL_get_session(ssl); | |
| 242 if (!session) | |
| 243 return; | |
| 244 | |
| 245 // Mark the session as good, allowing it to be used for future connections. | |
| 246 SSL_SESSION_set_ex_data( | |
| 247 session, GetSSLSessionExIndex(), reinterpret_cast<void*>(1)); | |
| 248 } | |
| 249 | |
| 250 // Flush all entries from the cache. | |
| 251 void Flush() { | |
| 252 base::AutoLock lock(lock_); | |
| 253 id_index_.clear(); | |
| 254 key_index_.clear(); | |
| 255 while (!ordering_.empty()) { | |
| 256 SSL_SESSION* session = ordering_.front(); | |
| 257 ordering_.pop_front(); | |
| 258 SSL_SESSION_free(session); | |
| 259 } | |
| 260 } | |
| 261 | |
| 262 private: | |
| 263 // Type for list of SSL_SESSION handles, ordered in MRU order. | |
| 264 typedef std::list<SSL_SESSION*> MRUSessionList; | |
| 265 // Type for a dictionary from unique cache keys to session list nodes. | |
| 266 typedef base::hash_map<std::string, MRUSessionList::iterator> KeyIndex; | |
| 267 // Type for a dictionary from SessionId values to key index nodes. | |
| 268 typedef base::hash_map<SessionId, KeyIndex::iterator> SessionIdIndex; | |
| 269 | |
| 270 // Return the key associated with a given session, or the empty string if | |
| 271 // none exist. This shall only be used for debugging. | |
| 272 std::string SessionKey(SSL_SESSION* session) { | |
| 273 if (!session) | |
| 274 return std::string("<null-session>"); | |
| 275 | |
| 276 if (session->session_id_length == 0) | |
| 277 return std::string("<empty-session-id>"); | |
| 278 | |
| 279 SessionIdIndex::iterator it = id_index_.find(SessionId(session)); | |
| 280 if (it == id_index_.end()) | |
| 281 return std::string("<unknown-session>"); | |
| 282 | |
| 283 return it->second->first; | |
| 284 } | |
| 285 | |
| 286 // Remove a given |session| from the cache. Lock must be held. | |
| 287 void RemoveSessionLocked(SSL_SESSION* session) { | |
| 288 lock_.AssertAcquired(); | |
| 289 DCHECK(session); | |
| 290 DCHECK_GT(session->session_id_length, 0U); | |
| 291 SessionId session_id(session); | |
| 292 SessionIdIndex::iterator id_it = id_index_.find(session_id); | |
| 293 if (id_it == id_index_.end()) { | |
| 294 LOG(ERROR) << "Trying to remove unknown session from cache: " << session; | |
| 295 return; | |
| 296 } | |
| 297 KeyIndex::iterator key_it = id_it->second; | |
| 298 DCHECK(key_it != key_index_.end()); | |
| 299 DCHECK_EQ(session, *key_it->second); | |
| 300 | |
| 301 id_index_.erase(session_id); | |
| 302 ordering_.erase(key_it->second); | |
| 303 key_index_.erase(key_it); | |
| 304 | |
| 305 SSL_SESSION_free(session); | |
| 306 | |
| 307 DCHECK_EQ(key_index_.size(), id_index_.size()); | |
| 308 } | |
| 309 | |
| 310 // Used internally to flush expired sessions. Lock must be held. | |
| 311 void FlushExpiredSessionsLocked() { | |
| 312 lock_.AssertAcquired(); | |
| 313 | |
| 314 // Unfortunately, OpenSSL initializes |session->time| with a time() | |
| 315 // timestamps, which makes mocking / unit testing difficult. | |
| 316 long timeout_secs = static_cast<long>(::time(NULL)); | |
| 317 MRUSessionList::iterator it = ordering_.begin(); | |
| 318 while (it != ordering_.end()) { | |
| 319 SSL_SESSION* session = *it++; | |
| 320 | |
| 321 // Important, use <= instead of < here to allow unit testing to | |
| 322 // work properly. That's because unit tests that check the expiration | |
| 323 // behaviour will use a session timeout of 0 seconds. | |
| 324 if (session->time + session->timeout <= timeout_secs) { | |
| 325 DVLOG(2) << "Expiring session " << session << " for " | |
| 326 << SessionKey(session); | |
| 327 RemoveSessionLocked(session); | |
| 328 } | |
| 329 } | |
| 330 } | |
| 331 | |
| 332 // Retrieve the cache associated with a given SSL context |ctx|. | |
| 333 static SSLSessionCacheOpenSSLImpl* GetCache(SSL_CTX* ctx) { | |
| 334 DCHECK(ctx); | |
| 335 void* result = SSL_CTX_get_ex_data(ctx, GetSSLContextExIndex()); | |
| 336 DCHECK(result); | |
| 337 return reinterpret_cast<SSLSessionCacheOpenSSLImpl*>(result); | |
| 338 } | |
| 339 | |
| 340 // Called by OpenSSL when a new |session| was created and added to a given | |
| 341 // |ssl| connection. Note that the session's reference count was already | |
| 342 // incremented before the function is entered. The function must return 1 | |
| 343 // to indicate that it took ownership of the session, i.e. that the caller | |
| 344 // should not decrement its reference count after completion. | |
| 345 static int NewSessionCallbackStatic(SSL* ssl, SSL_SESSION* session) { | |
| 346 GetCache(ssl->ctx)->OnSessionAdded(ssl, session); | |
| 347 return 1; | |
| 348 } | |
| 349 | |
| 350 // Called by OpenSSL to indicate that a session must be removed from the | |
| 351 // cache. This happens when SSL_CTX is destroyed. | |
| 352 static void RemoveSessionCallbackStatic(SSL_CTX* ctx, SSL_SESSION* session) { | |
| 353 GetCache(ctx)->OnSessionRemoved(session); | |
| 354 } | |
| 355 | |
| 356 // Called by OpenSSL to generate a new session ID. This happens during a | |
| 357 // SSL connection operation, when the SSL object doesn't have a session yet. | |
| 358 // | |
| 359 // A session ID is a random string of bytes used to uniquely identify the | |
| 360 // session between a client and a server. | |
| 361 // | |
| 362 // |ssl| is a SSL connection handle. Ignored here. | |
| 363 // |id| is the target buffer where the ID must be generated. | |
| 364 // |*id_len| is, on input, the size of the desired ID. It will be 16 for | |
| 365 // SSLv2, and 32 for anything else. OpenSSL allows an implementation | |
| 366 // to change it on output, but this will not happen here. | |
| 367 // | |
| 368 // The function must ensure the generated ID is really unique, i.e. that | |
| 369 // another session in the cache doesn't already use the same value. It must | |
| 370 // return 1 to indicate success, or 0 for failure. | |
| 371 static int GenerateSessionIdStatic(const SSL* ssl, | |
| 372 unsigned char* id, | |
| 373 unsigned* id_len) { | |
| 374 if (!GetCache(ssl->ctx)->OnGenerateSessionId(id, *id_len)) | |
| 375 return 0; | |
| 376 | |
| 377 return 1; | |
| 378 } | |
| 379 | |
| 380 // Add |session| to the cache in association with |cache_key|. If a session | |
| 381 // already exists, it is replaced with the new one. This assumes that the | |
| 382 // caller already incremented the session's reference count. | |
| 383 void OnSessionAdded(SSL* ssl, SSL_SESSION* session) { | |
| 384 base::AutoLock locked(lock_); | |
| 385 DCHECK(ssl); | |
| 386 DCHECK_GT(session->session_id_length, 0U); | |
| 387 std::string cache_key = config_.key_func(ssl); | |
| 388 KeyIndex::iterator it = key_index_.find(cache_key); | |
| 389 if (it == key_index_.end()) { | |
| 390 DVLOG(2) << "Add session " << session << " for " << cache_key; | |
| 391 // This is a new session. Add it to the cache. | |
| 392 ordering_.push_front(session); | |
| 393 std::pair<KeyIndex::iterator, bool> ret = | |
| 394 key_index_.insert(std::make_pair(cache_key, ordering_.begin())); | |
| 395 DCHECK(ret.second); | |
| 396 it = ret.first; | |
| 397 DCHECK(it != key_index_.end()); | |
| 398 } else { | |
| 399 // An existing session exists for this key, so replace it if needed. | |
| 400 DVLOG(2) << "Replace session " << *it->second << " with " << session | |
| 401 << " for " << cache_key; | |
| 402 SSL_SESSION* old_session = *it->second; | |
| 403 if (old_session != session) { | |
| 404 id_index_.erase(SessionId(old_session)); | |
| 405 SSL_SESSION_free(old_session); | |
| 406 } | |
| 407 ordering_.erase(it->second); | |
| 408 ordering_.push_front(session); | |
| 409 it->second = ordering_.begin(); | |
| 410 } | |
| 411 | |
| 412 id_index_[SessionId(session)] = it; | |
| 413 | |
| 414 if (key_index_.size() > config_.max_entries) | |
| 415 ShrinkCacheLocked(); | |
| 416 | |
| 417 DCHECK_EQ(key_index_.size(), id_index_.size()); | |
| 418 DCHECK_LE(key_index_.size(), config_.max_entries); | |
| 419 } | |
| 420 | |
| 421 // Shrink the cache to ensure no more than config_.max_entries entries, | |
| 422 // starting with older entries first. Lock must be acquired. | |
| 423 void ShrinkCacheLocked() { | |
| 424 lock_.AssertAcquired(); | |
| 425 DCHECK_EQ(key_index_.size(), ordering_.size()); | |
| 426 DCHECK_EQ(key_index_.size(), id_index_.size()); | |
| 427 | |
| 428 while (key_index_.size() > config_.max_entries) { | |
| 429 MRUSessionList::reverse_iterator it = ordering_.rbegin(); | |
| 430 DCHECK(it != ordering_.rend()); | |
| 431 | |
| 432 SSL_SESSION* session = *it; | |
| 433 DCHECK(session); | |
| 434 DVLOG(2) << "Evicting session " << session << " for " | |
| 435 << SessionKey(session); | |
| 436 RemoveSessionLocked(session); | |
| 437 } | |
| 438 } | |
| 439 | |
| 440 // Remove |session| from the cache. | |
| 441 void OnSessionRemoved(SSL_SESSION* session) { | |
| 442 base::AutoLock locked(lock_); | |
| 443 DVLOG(2) << "Remove session " << session << " for " << SessionKey(session); | |
| 444 RemoveSessionLocked(session); | |
| 445 } | |
| 446 | |
| 447 // See GenerateSessionIdStatic for a description of what this function does. | |
| 448 bool OnGenerateSessionId(unsigned char* id, unsigned id_len) { | |
| 449 base::AutoLock locked(lock_); | |
| 450 // This mimics def_generate_session_id() in openssl/ssl/ssl_sess.cc, | |
| 451 // I.e. try to generate a pseudo-random bit string, and check that no | |
| 452 // other entry in the cache has the same value. | |
| 453 const size_t kMaxTries = 10; | |
| 454 for (size_t tries = 0; tries < kMaxTries; ++tries) { | |
| 455 if (RAND_pseudo_bytes(id, id_len) <= 0) { | |
| 456 DLOG(ERROR) << "Couldn't generate " << id_len | |
| 457 << " pseudo random bytes?"; | |
| 458 return false; | |
| 459 } | |
| 460 if (id_index_.find(SessionId(id, id_len)) == id_index_.end()) | |
| 461 return true; | |
| 462 } | |
| 463 DLOG(ERROR) << "Couldn't generate unique session ID of " << id_len | |
| 464 << "bytes after " << kMaxTries << " tries."; | |
| 465 return false; | |
| 466 } | |
| 467 | |
| 468 SSL_CTX* ctx_; | |
| 469 SSLSessionCacheOpenSSL::Config config_; | |
| 470 | |
| 471 // method to get the index which can later be used with SSL_CTX_get_ex_data() | |
| 472 // or SSL_CTX_set_ex_data(). | |
| 473 base::Lock lock_; // Protects access to containers below. | |
| 474 | |
| 475 MRUSessionList ordering_; | |
| 476 KeyIndex key_index_; | |
| 477 SessionIdIndex id_index_; | |
| 478 | |
| 479 size_t expiration_check_; | |
| 480 }; | |
| 481 | |
| 482 SSLSessionCacheOpenSSL::~SSLSessionCacheOpenSSL() { delete impl_; } | |
| 483 | |
| 484 size_t SSLSessionCacheOpenSSL::size() const { return impl_->size(); } | |
| 485 | |
| 486 void SSLSessionCacheOpenSSL::Reset(SSL_CTX* ctx, const Config& config) { | |
| 487 if (impl_) | |
| 488 delete impl_; | |
| 489 | |
| 490 impl_ = new SSLSessionCacheOpenSSLImpl(ctx, config); | |
| 491 } | |
| 492 | |
| 493 bool SSLSessionCacheOpenSSL::SetSSLSession(SSL* ssl) { | |
| 494 return impl_->SetSSLSession(ssl); | |
| 495 } | |
| 496 | |
| 497 bool SSLSessionCacheOpenSSL::SetSSLSessionWithKey( | |
| 498 SSL* ssl, | |
| 499 const std::string& cache_key) { | |
| 500 return impl_->SetSSLSessionWithKey(ssl, cache_key); | |
| 501 } | |
| 502 | |
| 503 void SSLSessionCacheOpenSSL::MarkSSLSessionAsGood(SSL* ssl) { | |
| 504 return impl_->MarkSSLSessionAsGood(ssl); | |
| 505 } | |
| 506 | |
| 507 void SSLSessionCacheOpenSSL::Flush() { impl_->Flush(); } | |
| 508 | |
| 509 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 994263002:
Rewrite session cache in OpenSSL ports. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master