Ticket #120: nginx-rfc5077.patch

src/core/ngx_string.c

@@ -79 +79 @@
  *    %[0][width][u][x|X]L      int64_t/uint64_t
  *    %[0][width|m][u][x|X]A    ngx_atomic_int_t/ngx_atomic_uint_t
  *    %[0][width][.width]f      double, max valid number fits to %18.15f
+ *    %[x|X]*s                  length and string
  *    %P                        ngx_pid_t
  *    %M                        ngx_msec_t
  *    %r                        rlim_t
@@ -86 +87 @@
  *    %V                        ngx_str_t *
  *    %v                        ngx_variable_value_t *
  *    %s                        null-terminated string
- *    %*s                       length and string
  *    %Z                        '\0'
  *    %N                        '\n'
  *    %c                        char
@@ -141 +141 @@
 }
 
 
+static u_char   ngx_hex[] = "0123456789abcdef";
+static u_char   ngx_HEX[] = "0123456789ABCDEF";
+
 u_char *
 ngx_vslprintf(u_char *buf, u_char *last, const char *fmt, va_list args)
 {
-    u_char                *p, zero;
+    u_char                *p, zero, *hex_p;
     int                    d;
     double                 f;
     size_t                 len, slen;
@@ -250 +253 @@
             case 's':
                 p = va_arg(args, u_char *);
 
-                if (slen == (size_t) -1) {
-                    while (*p && buf < last) {
-                        *buf++ = *p++;
+                if (hex == 0) {
+                    if (slen == (size_t) -1) {
+                        while (*p && buf < last) {
+                            *buf++ = *p++;
+                        }
+                    } else {
+                        len = ngx_min(((size_t) (last - buf)), slen);
+                        buf = ngx_cpymem(buf, p, len);
                     }
-
                 } else {
-                    len = ngx_min(((size_t) (last - buf)), slen);
-                    buf = ngx_cpymem(buf, p, len);
+                    if ( hex == 1 ) {
+                        hex_p = ngx_hex;
+                    } else {
+                        hex_p = ngx_HEX;
+                    }
+                    while (buf < (last-1)) {
+                        if ( slen == (size_t) -1) {
+                            if (!*p) break;
+                        } else {
+                            if ( slen == 0 ) {
+                                break;
+                            } else {
+                                --slen;
+                            }
+                        }
+                        *buf++ = hex_p[ ((uint32_t) *p & 0xf0) >> 4];
+                        *buf++ = hex_p[ ((uint32_t) *p) & 0xf];
+                        ++p;
+                    }
                 }
 
                 fmt++;
@@ -479 +503 @@
                         */
     size_t          len;
     uint32_t        ui32;
-    static u_char   hex[] = "0123456789abcdef";
-    static u_char   HEX[] = "0123456789ABCDEF";
 
     p = temp + NGX_INT64_LEN;
 
@@ -520 +542 @@
         do {
 
             /* the "(uint32_t)" cast disables the BCC's warning */
-            *--p = hex[(uint32_t) (ui64 & 0xf)];
+            *--p = ngx_hex[(uint32_t) (ui64 & 0xf)];
 
         } while (ui64 >>= 4);
 
@@ -529 +551 @@
         do {
 
             /* the "(uint32_t)" cast disables the BCC's warning */
-            *--p = HEX[(uint32_t) (ui64 & 0xf)];
+            *--p = ngx_HEX[(uint32_t) (ui64 & 0xf)];
 
         } while (ui64 >>= 4);
     }

src/event/ngx_event_openssl.c

@@ -27 +27 @@
     ngx_err_t err, char *text);
 static void ngx_ssl_clear_error(ngx_log_t *log);
 
-ngx_int_t ngx_ssl_session_cache_init(ngx_shm_zone_t *shm_zone, void *data);
+ngx_int_t ngx_ssl_cache_init(ngx_shm_zone_t *shm_zone, void *data);
 static int ngx_ssl_new_session(ngx_ssl_conn_t *ssl_conn,
     ngx_ssl_session_t *sess);
 static ngx_ssl_session_t *ngx_ssl_get_cached_session(ngx_ssl_conn_t *ssl_conn,
@@ -38 +38 @@
 static void ngx_ssl_session_rbtree_insert_value(ngx_rbtree_node_t *temp,
     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);
 
+static int ngx_ssl_tlsext_ticket_key_cb(SSL *s, unsigned char *key_name,
+    unsigned char *iv, EVP_CIPHER_CTX *ctx, HMAC_CTX *hctx, int enc);
+static ngx_int_t ngx_ssl_ticket_cache_init(ngx_ssl_ticket_cache_t *cache, ngx_log_t *log);
+static ngx_int_t ngx_ssl_ticket_new(ngx_ssl_ticket_cache_t *cache, unsigned i, long expire);
+
 static void *ngx_openssl_create_conf(ngx_cycle_t *cycle);
 static char *ngx_openssl_engine(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
 static void ngx_openssl_exit(ngx_cycle_t *cycle);
@@ -80 +85 @@
 
 
 int  ngx_ssl_connection_index;
-int  ngx_ssl_server_conf_index;
 int  ngx_ssl_session_cache_index;
+int  ngx_ssl_ticket_timeout_index;
 
 
 ngx_int_t
@@ -115 +120 @@
     ngx_ssl_connection_index = SSL_get_ex_new_index(0, NULL, NULL, NULL, NULL);
 
     if (ngx_ssl_connection_index == -1) {
-        ngx_ssl_error(NGX_LOG_ALERT, log, 0, "SSL_get_ex_new_index() failed");
-        return NGX_ERROR;
-    }
-
-    ngx_ssl_server_conf_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL,
-                                                         NULL);
-    if (ngx_ssl_server_conf_index == -1) {
         ngx_ssl_error(NGX_LOG_ALERT, log, 0,
-                      "SSL_CTX_get_ex_new_index() failed");
+                      "SSL_CTX_get_ex_new_index() for ssl_connection failed");
         return NGX_ERROR;
     }
 
@@ -131 +129 @@
                                                            NULL);
     if (ngx_ssl_session_cache_index == -1) {
         ngx_ssl_error(NGX_LOG_ALERT, log, 0,
-                      "SSL_CTX_get_ex_new_index() failed");
+                      "SSL_CTX_get_ex_new_index() for session cache failed");
         return NGX_ERROR;
     }
 
+    ngx_ssl_ticket_timeout_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL,
+                                                           NULL);
+    if (ngx_ssl_ticket_timeout_index == -1) {
+        ngx_ssl_error(NGX_LOG_ALERT, log, 0,
+                      "SSL_CTX_get_ex_new_index() for ticket_timeout failed");
+        return NGX_ERROR;
+    }
     return NGX_OK;
 }
 
@@ -149 +154 @@
         return NGX_ERROR;
     }
 
-    if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_server_conf_index, data) == 0) {
-        ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
-                      "SSL_CTX_set_ex_data() failed");
-        return NGX_ERROR;
-    }
-
     /* client side options */
 
     SSL_CTX_set_options(ssl->ctx, SSL_OP_MICROSOFT_SESS_ID_BUG);
@@ -1513 +1512 @@
 
 ngx_int_t
 ngx_ssl_session_cache(ngx_ssl_t *ssl, ngx_str_t *sess_ctx,
-    ssize_t builtin_session_cache, ngx_shm_zone_t *shm_zone, time_t timeout)
+    ssize_t builtin_session_cache, ngx_shm_zone_t *shm_zone,
+    time_t session_timeout, time_t *ticket_timeout)
 {
     long  cache_mode;
 
@@ -1562 +1562 @@
         }
     }
 
-    SSL_CTX_set_timeout(ssl->ctx, (long) timeout);
+    SSL_CTX_set_timeout(ssl->ctx, (long) session_timeout);
 
     if (shm_zone) {
         SSL_CTX_sess_set_new_cb(ssl->ctx, ngx_ssl_new_session);
         SSL_CTX_sess_set_get_cb(ssl->ctx, ngx_ssl_get_cached_session);
         SSL_CTX_sess_set_remove_cb(ssl->ctx, ngx_ssl_remove_session);
 
+        SSL_CTX_set_tlsext_ticket_key_cb(ssl->ctx, ngx_ssl_tlsext_ticket_key_cb);
+
+        if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_ticket_timeout_index,
+                                ticket_timeout) == 0)
+        {
+            ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
+                          "SSL_CTX_set_ex_data() for ticket timeout failed");
+            return NGX_ERROR;
+        }
+
         if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_session_cache_index, shm_zone)
             == 0)
         {
             ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
-                          "SSL_CTX_set_ex_data() failed");
+                          "SSL_CTX_set_ex_data() for session cache failed");
             return NGX_ERROR;
         }
     }
@@ -1583 +1593 @@
 
 
 ngx_int_t
-ngx_ssl_session_cache_init(ngx_shm_zone_t *shm_zone, void *data)
+ngx_ssl_cache_init(ngx_shm_zone_t *shm_zone, void *data)
 {
     size_t                    len;
     ngx_slab_pool_t          *shpool;
-    ngx_ssl_session_cache_t  *cache;
+    ngx_ssl_cache_t          *cache;
 
     if (data) {
         shm_zone->data = data;
@@ -1601 +1611 @@
 
     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;
 
-    cache = ngx_slab_alloc(shpool, sizeof(ngx_ssl_session_cache_t));
+    cache = ngx_slab_alloc(shpool, sizeof(ngx_ssl_cache_t));
     if (cache == NULL) {
         return NGX_ERROR;
     }
@@ -1609 +1619 @@
     shpool->data = cache;
     shm_zone->data = cache;
 
-    ngx_rbtree_init(&cache->session_rbtree, &cache->sentinel,
+    ngx_rbtree_init(&cache->session.session_rbtree, &cache->session.sentinel,
                     ngx_ssl_session_rbtree_insert_value);
 
-    ngx_queue_init(&cache->expire_queue);
+    ngx_queue_init(&cache->session.expire_queue);
 
-    len = sizeof(" in SSL session shared cache \"\"") + shm_zone->shm.name.len;
+    len = sizeof(" in SSL shared cache \"\"") + shm_zone->shm.name.len;
 
     shpool->log_ctx = ngx_slab_alloc(shpool, len);
     if (shpool->log_ctx == NULL) {
         return NGX_ERROR;
     }
 
-    ngx_sprintf(shpool->log_ctx, " in SSL session shared cache \"%V\"%Z",
+    ngx_sprintf(shpool->log_ctx, " in SSL shared cache \"%V\"%Z",
                 &shm_zone->shm.name);
 
+    ngx_ssl_ticket_cache_init(&cache->ticket, shm_zone->shm.log);
+
+    return NGX_OK;
+}
+
+/* ssl tickets are RFC5077 tickets where the server 
+ * doesn't maintain a session crypto state for each client
+ * Like session IDs it provides a mechanism for the client
+ * to short cut the cryptographic exchange. It does this by
+ * encrypting the crypto state information in the ticket
+ * and providing it to the client.
+ *
+ * The server size cyptographic parameters that encrypt the
+ * session expire for the same time as the session cache.
+ * They are however renewed in 1/2 that time so clients can
+ * progress to the new state without doing a full cryptographic
+ * exchange. See note below about poor client support.
+ */
+
+static ngx_int_t
+ngx_ssl_ticket_cache_init(ngx_ssl_ticket_cache_t *cache, ngx_log_t *log)
+{
+    int i;
+
+    for (i = 0; i< NGX_SSL_ACTIVE_TICKETS; i++) {
+        cache->keystore[i].keys.expire = (unsigned long) -1;
+    }
+    cache->keystore_i = 0;
+#if (NGX_THREADS)
+    cache->keyrefresh = ngx_mutex_init(log, 0);
+    if (cache->keyrefresh == NULL) {
+        ngx_log_error(NGX_LOG_ERR, log, 0,
+            "key refresh mutex initialisation failure");
+        return NGX_ERROR;
+    }
+#endif
+    return NGX_OK;
+}
+
+
+#define NGX_RENEW_SSL_TICKET
+/* Suspect that some clients aren't handling renewals properly
+ * despite being in rfc5077 3.3 paragraph 2.
+ * Tested clients:
+ * nss 3.13.5
+ * gnutls 2.12.17
+ * openssl 1.0.0j 
+ *
+ * returns 0 if expired, 1 if early and valid, 2 if renew */
+static ngx_int_t ngx_ssl_ticket_valid(time_t now, time_t ref, long expire) {
+#ifdef NGX_RENEW_SSL_TICKET
+   long renew = expire / 2;
+#endif
+    if ( now <= ref ) {
+#ifdef NGX_RENEW_SSL_TICKET
+      if ( now < (ref - renew) ) {
+        return 1;
+      }  else {
+        return 2;
+      }
+#else
+      return 1;
+#endif
+    } else {
+      return 0;
+    }
+}
+
+static ngx_int_t
+ngx_ssl_ticket_new(ngx_ssl_ticket_cache_t *cache,unsigned i, long expire)
+{
+    ngx_ssl_ticket_id_t *keys = &cache->keystore[i];
+    if ((RAND_bytes(keys->keys.hmac_key, 16) <= 0)
+        || (RAND_bytes(keys->keys.aes_key, 16) <= 0)
+        || (RAND_pseudo_bytes(keys->key_name, 16) <= 0))
+        return NGX_ERROR;
+    keys->keys.expire = ngx_time() + expire;
     return NGX_OK;
 }
 
 
+static int
+ngx_ssl_tlsext_ticket_key_create(ngx_ssl_ticket_cache_t *cache, ngx_log_t *log,
+    unsigned char *key_name, unsigned char *iv, EVP_CIPHER_CTX *ctx,
+    HMAC_CTX *hctx, long expiretime)
+{
+    time_t                   t;
+    unsigned                 newi;
+    ngx_ssl_ticket_id_t      *k;
+
+    t = ngx_time();
+
+    /* create new session */
+    if (RAND_bytes(iv, EVP_MAX_IV_LENGTH) <= 0) {
+        ngx_log_error(NGX_LOG_WARN, log, 0,
+            "RAND_bytes entropy empty on iv initialisation");
+        return -1;
+    }
+    ngx_log_debug5(NGX_LOG_DEBUG_EVENT, log, 0,
+            "New iv %*Xs time %T current key expire %T expire interval %l",
+            (size_t) EVP_MAX_IV_LENGTH, iv,
+            t, cache->keystore[cache->keystore_i].keys.expire,
+            expiretime);
+    switch ( ngx_ssl_ticket_valid(t, cache->keystore[cache->keystore_i].keys.expire,
+             expiretime)) {
+    case 1:
+        ngx_log_error(NGX_LOG_WARN, log, 0,
+                  "current ticket sufficient");
+        break;
+    case 2:
+        ngx_log_debug(NGX_LOG_DEBUG_EVENT, log, 0,
+              "session ticket key valid but in renew period - use new key");
+        /* time for a new key */
+#if (NGX_THREADS)
+        ngx_shmtx_lock(cache->keyrefresh);
+#endif
+        /* check the next entry is expired inside the mutex to avoid a race
+         * condition if another worker already updated this */
+        newi = ( cache->keystore_i + 1) % NGX_SSL_ACTIVE_TICKETS;
+        if ( ngx_ssl_ticket_valid(t, cache->keystore[newi].keys.expire,
+             expiretime) == 0) {
+            if (ngx_ssl_ticket_new(cache,newi,expiretime) == NGX_OK) {
+                ngx_log_error(NGX_LOG_INFO, log, 0,
+                              "New ssl session ticket generated");
+            } else {
+                /* insufficent randomness */
+                ngx_log_error(NGX_LOG_WARN, log, 0,
+                    "RAND_bytes entropy empty on new key material");
+#if (NGX_THREADS)
+                ngx_shmtx_unlock(cache->keyrefresh);
+#endif
+                return -1;
+            }
+            cache->keystore_i = newi;
+            ngx_log_debug7(NGX_LOG_DEBUG_EVENT, log, 0,
+                   "New key/hmac for SSL session ticket key %d name %*Xs"
+                   "aes_key %*Xs hmac_key %*Xs",
+                   newi,
+                   (size_t)16, cache->keystore[newi].key_name,
+                   (size_t)16, cache->keystore[newi].keys.aes_key,
+                   (size_t)16, cache->keystore[newi].keys.hmac_key);
+        } else {
+            ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0, "Was tasked to SSL"
+                "session renew ticket %d but it wasn't expired. Assume another"
+                "thread/process fixed it for us", newi);
+        }
+#if (NGX_THREADS)
+        ngx_shmtx_unlock(cache->keyrefresh);
+#endif
+        break;
+    case 0:
+        /* primary key expired */
+        ngx_log_debug(NGX_LOG_DEBUG_EVENT, log, 0,
+              "SSL session ticket current key expired - generating");
+#if (NGX_THREADS)
+        ngx_shmtx_lock(cache->keyrefresh);
+#endif
+        /* race condition prevention inside mutex */
+        if ( ngx_ssl_ticket_valid(t, 
+            cache->keystore[cache->keystore_i].keys.expire, expiretime) == 0) {
+            if (ngx_ssl_ticket_new(cache,cache->keystore_i, expiretime)
+                == NGX_OK) {
+                ngx_log_error(NGX_LOG_INFO, log, 0,
+                              "New ssl session ticket generated");
+            } else {
+                /* insufficent randomness */
+                ngx_log_error(NGX_LOG_WARN, log, 0,
+                    "RAND_bytes entropy empty on new key material");
+#if (NGX_THREADS)
+                ngx_shmtx_unlock(&(cache->keyrefresh));
+#endif
+                return -1;
+            }
+        } else {
+            ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0,
+               "SSL session ticket was to renew current ticket %d but it wasn't"
+               " expired. Assume another thread/process fixed it for us"
+               , cache->keystore_i);
+        }
+        newi = cache->keystore_i;      
+#if (NGX_THREADS)
+        ngx_shmtx_unlock(&(cache->keyrefresh));
+#endif
+        ngx_log_debug7(NGX_LOG_DEBUG_EVENT, log, 0,
+            "New key/hmac for SSL session ticket key %d name %*Xs aes_key %*Xs"
+            " hmac_key %*Xs",
+            newi,
+            (size_t) 16, cache->keystore[newi].key_name,
+            (size_t) 16, cache->keystore[newi].keys.aes_key,
+            (size_t) 16, cache->keystore[newi].keys.hmac_key);
+    }
+    k = &cache->keystore[cache->keystore_i];
+    ngx_memcpy(key_name, k->key_name, 16);
+    
+    EVP_EncryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, k->keys.aes_key, iv);
+    HMAC_Init_ex(hctx, k->keys.hmac_key, 16, EVP_sha256(), NULL);
+    ngx_log_debug7(NGX_LOG_DEBUG_EVENT, log, 0,
+         "New SSL session ticket %d with name %*Xs aes_key %*Xs hmac_key %*Xs",
+         cache->keystore_i,
+         (size_t) 16, k->key_name,
+         (size_t) 16, k->keys.aes_key,
+         (size_t) 16, k->keys.hmac_key);
+    return 1;
+}
+
+/* tip copied off the Apache httpd source - assumed tlsext_tick_md didn't exist
+ * at some version of openssl */
+#ifndef tlsext_tick_md
+#ifdef OPENSSL_NO_SHA256
+#define tlsext_tick_md EVP_sha1
+#else
+#define tlsext_tick_md EVP_sha256
+#endif
+#endif
+
+static int
+ngx_ssl_tlsext_ticket_key_cb(ngx_ssl_conn_t *s, unsigned char *key_name,
+    unsigned char *iv, EVP_CIPHER_CTX *ctx, HMAC_CTX *hctx, int enc)
+{
+    SSL_CTX                  *ssl_ctx;
+    ngx_shm_zone_t           *shm_zone;
+    ngx_ssl_cache_t          *bigcache;
+    ngx_ssl_ticket_cache_t   *cache;
+    ngx_connection_t         *c;
+    ngx_log_t                *log;
+    time_t                   t;
+    ngx_ssl_ticket_keys_t    *keys;
+    unsigned                 a;
+    unsigned                 i;
+    int                      cmp;
+    int                      renew;
+    long                     expiretime;
+
+    ssl_ctx = SSL_get_SSL_CTX(s);
+    shm_zone = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_session_cache_index);
+    expiretime = *((long *) SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_ticket_timeout_index));
+    bigcache = shm_zone->data;
+    cache = &bigcache->ticket;
+
+    c = ngx_ssl_get_connection(s);
+    log = c->log;
+    t = ngx_time();
+
+    ngx_log_debug5(NGX_LOG_DEBUG_EVENT, log, 0,
+                   "tlsext_ticket_key_cb (in): key_name: %*Xs iv: %*Xs enc %d",
+                    (size_t) 16, key_name,
+                    (size_t) EVP_MAX_IV_LENGTH, iv,
+                    enc);
+    if (enc) {
+        return ngx_ssl_tlsext_ticket_key_create(cache, log, key_name, iv, ctx,
+            hctx,expiretime);
+    } else {
+        /* retrieve session */
+        a = 0;
+        cmp = -1;
+        for (i = a = cache->keystore_i;
+                i < NGX_SSL_ACTIVE_TICKETS &&
+                (cmp = ngx_memcmp(key_name, cache->keystore[a].key_name,16)!=0);
+             ++i, a = (a + 1) % NGX_SSL_ACTIVE_TICKETS);
+        if (cmp == 0) {
+            keys = &cache->keystore[a].keys;
+        } else {
+            ngx_log_debug2(NGX_LOG_DEBUG_EVENT, log, 0, "SSL session ticket key "
+                "%*Xs not found", (size_t) 16, key_name);
+            return 0;
+        }
+        renew = ngx_ssl_ticket_valid(t, cache->keystore[a].keys.expire,
+            expiretime);
+        if (renew == 0) {
+            ngx_log_debug3(NGX_LOG_DEBUG_EVENT, log, 0, "retreiving key %d "
+                "expired %T < now %T", a, keys->expire, t);
+            return 0;
+        }
+
+        HMAC_Init_ex(hctx, keys->hmac_key, 16, tlsext_tick_md(), NULL);
+        EVP_DecryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, keys->aes_key, iv);
+        ngx_log_debug8(NGX_LOG_DEBUG_EVENT, log, 0,
+            "Resumed SSL session ticket %d with iv %*Xs aes_key %*Xs "
+            "hmac_key %*Xs renew %s",
+            a,
+            (size_t) 16, iv,
+            (size_t) 16, keys->aes_key,
+            (size_t) 16, keys->hmac_key,
+            ((renew == 2) ? "yes" : "no"));
+        if  (renew == 2) {
+            /* this sesssion will get a new ticket. This is handled in the ssl
+             * library and will call this function again with a enc=0 */
+            ngx_log_debug5(NGX_LOG_DEBUG_EVENT, log, 0,
+                           "tlsext_ticket_key_cb (out): key_name: %*Xs iv: %*Xs"
+                           " enc %d ret 2",
+                           (size_t) 16, key_name,
+                           (size_t) EVP_MAX_IV_LENGTH, iv,
+                           enc);
+            return 2;
+        }
+    }
+    ngx_log_debug5(NGX_LOG_DEBUG_EVENT, log, 0,
+                   "tlsext_ticket_key_cb (out): key_name: %*Xs iv: %*Xs enc %d - ret 1",
+                   (size_t) 16, key_name,
+                   (size_t) EVP_MAX_IV_LENGTH, iv,
+                   enc);
+    return 1;
+}
+
+
+
+
+
 /*
  * The length of the session id is 16 bytes for SSLv2 sessions and
  * between 1 and 32 bytes for SSLv3/TLSv1, typically 32 bytes.
@@ -1661 +1975 @@
 
     len = i2d_SSL_SESSION(sess, NULL);
 
+
+    /* This isn't called if a session ticket is created
+     * see rfc5077 3.4
+     */
+
     /* do not cache too big session */
 
     if (len > (int) NGX_SSL_MAX_SESSION_SIZE) {
@@ -1675 +1994 @@
     ssl_ctx = SSL_get_SSL_CTX(ssl_conn);
     shm_zone = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_session_cache_index);
 
-    cache = shm_zone->data;
+    cache = &((ngx_ssl_cache_t  *) shm_zone->data)->session;
     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;
 
     ngx_shmtx_lock(&shpool->mutex);
@@ -1796 +2115 @@
     shm_zone = SSL_CTX_get_ex_data(SSL_get_SSL_CTX(ssl_conn),
                                    ngx_ssl_session_cache_index);
 
-    cache = shm_zone->data;
+    cache = &((ngx_ssl_cache_t  *) shm_zone->data)->session;
 
     sess = NULL;
 
@@ -1892 +2211 @@
         return;
     }
 
-    cache = shm_zone->data;
+    cache = &((ngx_ssl_cache_t  *) shm_zone->data)->session;
 
     id = sess->session_id;
     len = (size_t) sess->session_id_length;

src/event/ngx_event_openssl.h

@@ -81 +81 @@
 } ngx_ssl_session_cache_t;
 
 
+/* RFC 5077 */
+typedef struct {
+        u_char    hmac_key[16];
+        u_char    aes_key[16];
+        time_t    expire;
+} ngx_ssl_ticket_keys_t;
+
+
+typedef struct {
+        u_char                    key_name[16];
+        ngx_ssl_ticket_keys_t     keys;
+} ngx_ssl_ticket_id_t;
+
+
+#define NGX_SSL_ACTIVE_TICKETS  2
+typedef struct {
+    volatile unsigned      keystore_i;
+    ngx_ssl_ticket_id_t    keystore[NGX_SSL_ACTIVE_TICKETS];
+#if (NGX_THREADS)
+    ngx_shmtx_t            *keyrefresh;
+#endif
+} ngx_ssl_ticket_cache_t;
+
+
+typedef struct {
+    ngx_ssl_session_cache_t session;
+    ngx_ssl_ticket_cache_t ticket;
+} ngx_ssl_cache_t;
+
 
 #define NGX_SSL_SSLv2    0x0002
 #define NGX_SSL_SSLv3    0x0004
@@ -106 +135 @@
 ngx_int_t ngx_ssl_dhparam(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *file);
 ngx_int_t ngx_ssl_ecdh_curve(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *name);
 ngx_int_t ngx_ssl_session_cache(ngx_ssl_t *ssl, ngx_str_t *sess_ctx,
-    ssize_t builtin_session_cache, ngx_shm_zone_t *shm_zone, time_t timeout);
-ngx_int_t ngx_ssl_session_cache_init(ngx_shm_zone_t *shm_zone, void *data);
+    ssize_t builtin_session_cache, ngx_shm_zone_t *shm_zone,
+    time_t session_timeout, long *ticket_timeout);
+ngx_int_t ngx_ssl_cache_init(ngx_shm_zone_t *shm_zone, void *data);
 ngx_int_t ngx_ssl_create_connection(ngx_ssl_t *ssl, ngx_connection_t *c,
     ngx_uint_t flags);
 
@@ -117 +147 @@
 #define ngx_ssl_free_session        SSL_SESSION_free
 #define ngx_ssl_get_connection(ssl_conn)                                      \
     SSL_get_ex_data(ssl_conn, ngx_ssl_connection_index)
-#define ngx_ssl_get_server_conf(ssl_ctx)                                      \
-    SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_server_conf_index)
 
 
 ngx_int_t ngx_ssl_get_protocol(ngx_connection_t *c, ngx_pool_t *pool,
@@ -155 +183 @@
 
 
 extern int  ngx_ssl_connection_index;
-extern int  ngx_ssl_server_conf_index;
 extern int  ngx_ssl_session_cache_index;
 
 

src/http/modules/ngx_http_ssl_module.c

@@ -145 +145 @@
       offsetof(ngx_http_ssl_srv_conf_t, session_timeout),
       NULL },
 
+    { ngx_string("ssl_ticket_timeout"),
+      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
+      ngx_conf_set_sec_slot,
+      NGX_HTTP_SRV_CONF_OFFSET,
+      offsetof(ngx_http_ssl_srv_conf_t, ticket_timeout),
+      NULL },
+
     { ngx_string("ssl_crl"),
       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
       ngx_conf_set_str_slot,
@@ -336 +343 @@
     sscf->verify_depth = NGX_CONF_UNSET_UINT;
     sscf->builtin_session_cache = NGX_CONF_UNSET;
     sscf->session_timeout = NGX_CONF_UNSET;
+    sscf->ticket_timeout = NGX_CONF_UNSET;
 
     return sscf;
 }
@@ -363 +371 @@
     ngx_conf_merge_value(conf->session_timeout,
                          prev->session_timeout, 300);
 
+    ngx_conf_merge_value(conf->ticket_timeout,
+                         prev->ticket_timeout, 60*60*24*7); /* 1 week */
+
     ngx_conf_merge_value(conf->prefer_server_ciphers,
                          prev->prefer_server_ciphers, 0);
 
@@ -509 +520 @@
 
     if (ngx_ssl_session_cache(&conf->ssl, &ngx_http_ssl_sess_id_ctx,
                               conf->builtin_session_cache,
-                              conf->shm_zone, conf->session_timeout)
+                              conf->shm_zone, conf->session_timeout,
+                              &conf->ticket_timeout)
         != NGX_OK)
     {
         return NGX_CONF_ERROR;
@@ -629 +641 @@
                 return NGX_CONF_ERROR;
             }
 
-            sscf->shm_zone->init = ngx_ssl_session_cache_init;
+            sscf->shm_zone->init = ngx_ssl_cache_init;
 
             continue;
         }

src/http/modules/ngx_http_ssl_module.h

@@ -29 +29 @@
     ssize_t                         builtin_session_cache;
 
     time_t                          session_timeout;
+    long                            ticket_timeout;
 
     ngx_str_t                       certificate;
     ngx_str_t                       certificate_key;

src/mail/ngx_mail_ssl_module.c

@@ -123 +123 @@
       offsetof(ngx_mail_ssl_conf_t, session_timeout),
       NULL },
 
+    { ngx_string("ssl_ticket_session_timeout"),
+      NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_TAKE1,
+      ngx_conf_set_sec_slot,
+      NGX_MAIL_SRV_CONF_OFFSET,
+      offsetof(ngx_mail_ssl_conf_t, ticket_timeout),
+      NULL },
+
       ngx_null_command
 };
 
@@ -184 +191 @@
     scf->prefer_server_ciphers = NGX_CONF_UNSET;
     scf->builtin_session_cache = NGX_CONF_UNSET;
     scf->session_timeout = NGX_CONF_UNSET;
+    scf->ticket_timeout = NGX_CONF_UNSET;
 
     return scf;
 }
@@ -205 +213 @@
     ngx_conf_merge_value(conf->session_timeout,
                          prev->session_timeout, 300);
 
+    ngx_conf_merge_value(conf->ticket_timeout,
+                         prev->ticket_timeout, 60*60*24*7); /* 1 week */
+
     ngx_conf_merge_value(conf->prefer_server_ciphers,
                          prev->prefer_server_ciphers, 0);
 
@@ -317 +328 @@
 
     if (ngx_ssl_session_cache(&conf->ssl, &ngx_mail_ssl_sess_id_ctx,
                               conf->builtin_session_cache,
-                              conf->shm_zone, conf->session_timeout)
+                              conf->shm_zone, conf->session_timeout,
+                              &conf->ticket_timeout)
         != NGX_OK)
     {
         return NGX_CONF_ERROR;
@@ -468 +480 @@
                 return NGX_CONF_ERROR;
             }
 
-            scf->shm_zone->init = ngx_ssl_session_cache_init;
+            scf->shm_zone->init = ngx_ssl_cache_init;
 
             continue;
         }

src/mail/ngx_mail_ssl_module.h

@@ -31 +31 @@
     ssize_t          builtin_session_cache;
 
     time_t           session_timeout;
+    long             ticket_timeout;
 
     ngx_str_t        certificate;
     ngx_str_t        certificate_key;