diff --git a/cmake/JSSConfig.cmake b/cmake/JSSConfig.cmake
index 9ccb148bb..373b4d155 100644
--- a/cmake/JSSConfig.cmake
+++ b/cmake/JSSConfig.cmake
@@ -349,6 +349,10 @@ macro(jss_config_template)
         "${PROJECT_SOURCE_DIR}/tools/run_test.sh.in"
         "${CMAKE_BINARY_DIR}/run_test.sh"
     )
+    configure_file(
+        "${PROJECT_SOURCE_DIR}/tools/run_java.sh.in"
+        "${CMAKE_BINARY_DIR}/run_java.sh"
+    )
     set(JSS_CFG_PATH "${CONFIG_OUTPUT_DIR}/jss.cfg")
     configure_file(
         "${PROJECT_SOURCE_DIR}/tools/java.security.in"
diff --git a/cmake/JSSTests.cmake b/cmake/JSSTests.cmake
index 6f31ad2a2..68a7df93e 100644
--- a/cmake/JSSTests.cmake
+++ b/cmake/JSSTests.cmake
@@ -70,6 +70,10 @@ macro(jss_tests)
         NAME "TestBufferPRFD"
         COMMAND "${BIN_OUTPUT_DIR}/TestBufferPRFD"
     )
+    jss_test_java(
+        NAME "TestJByteBuffer"
+        COMMAND "org.mozilla.jss.tests.TestJByteBuffer"
+    )
     jss_test_java(
         NAME "Test_UTF-8_Converter"
         COMMAND "org.mozilla.jss.tests.UTF8ConverterTest"
@@ -175,6 +179,11 @@ macro(jss_tests)
         COMMAND "pk12util" "-o" "${RESULTS_NSSDB_OUTPUT_DIR}/rsa.pfx" "-n" "CA_RSA" "-d" "${RESULTS_NSSDB_OUTPUT_DIR}" "-K" "${DB_PWD}" "-W" "${DB_PWD}"
         DEPENDS "Generate_known_RSA_cert_pair"
     )
+    jss_test_exec(
+        NAME "Create_PKCS11_cert_to_PKCS12_server_rsa.pfx"
+        COMMAND "pk12util" "-o" "${RESULTS_NSSDB_OUTPUT_DIR}/rsa-server.pfx" "-n" "Server_RSA" "-d" "${RESULTS_NSSDB_OUTPUT_DIR}" "-K" "${DB_PWD}" "-W" "${DB_PWD}"
+        DEPENDS "Generate_known_RSA_cert_pair"
+    )
     jss_test_exec(
         NAME "Create_PKCS11_cert_to_PKCS12_ecdsa.pfx"
         COMMAND "pk12util" "-o" "${RESULTS_NSSDB_OUTPUT_DIR}/ecdsa.pfx" "-n" "CA_ECDSA" "-d" "${RESULTS_NSSDB_OUTPUT_DIR}" "-K" "${DB_PWD}" "-W" "${DB_PWD}"
diff --git a/docs/usage/benchmarksslsocket.md b/docs/usage/benchmarksslsocket.md
index 63504689e..6fbde52be 100644
--- a/docs/usage/benchmarksslsocket.md
+++ b/docs/usage/benchmarksslsocket.md
@@ -37,7 +37,10 @@ java.security. When utilizing SunJSSE, for best results, do not load
 JSS via java.security.
 
 It is suggested to use `run_test.sh` from the `build/` directory for
-executing this utility.
+executing this utility. `run_java.sh` can be used when benchmarking
+`SunJSSE.SSLSocket` as it doesn't load JSS via the `java.security`
+file by default. Additionally, a RSA server certificate is placed
+under `build/results/nssdb/rsa-ssl.pfx` with the default password.
 
 # Past Performance
 
diff --git a/lib/jss.map b/lib/jss.map
index 8a6fdcb2f..eeb18c661 100644
--- a/lib/jss.map
+++ b/lib/jss.map
@@ -482,6 +482,14 @@ Java_org_mozilla_jss_nss_SECErrors_getRevokedCertificateOCSP;
 Java_org_mozilla_jss_nss_SECErrors_getRevokedCertificate;
 Java_org_mozilla_jss_nss_SECErrors_getUntrustedIssuer;
 Java_org_mozilla_jss_nss_SECErrors_getUntrustedCert;
+Java_org_mozilla_jss_nss_Buffer_ReadOffset;
+Java_org_mozilla_jss_nss_Buffer_WriteOffset;
+Java_org_mozilla_jss_nss_JByteBuffer_Create;
+Java_org_mozilla_jss_nss_JByteBuffer_ClearBufferNative;
+Java_org_mozilla_jss_nss_JByteBuffer_SetBufferNative;
+Java_org_mozilla_jss_nss_JByteBuffer_Capacity;
+Java_org_mozilla_jss_nss_JByteBuffer_FreeNative;
+Java_org_mozilla_jss_nss_PR_NewByteBufferPRFD;
     local:
         *;
 };
diff --git a/src/main/java/org/mozilla/jss/nss/ByteBufferProxy.c b/src/main/java/org/mozilla/jss/nss/ByteBufferProxy.c
new file mode 100644
index 000000000..822be5270
--- /dev/null
+++ b/src/main/java/org/mozilla/jss/nss/ByteBufferProxy.c
@@ -0,0 +1,51 @@
+#include <nspr.h>
+#include <jni.h>
+
+#include "java_ids.h"
+#include "jssutil.h"
+#include "ByteBufferProxy.h"
+
+jobject
+JSS_PR_wrapJByteBuffer(JNIEnv *env, j_bytebuffer **buffer)
+{
+    jbyteArray pointer = NULL;
+    jclass proxyClass;
+    jmethodID constructor;
+    jobject bufferObj = NULL;
+
+    PR_ASSERT(env != NULL && buffer != NULL && *buffer != NULL);
+
+    /* convert pointer to byte array */
+    pointer = JSS_ptrToByteArray(env, *buffer);
+
+    /*
+     * Lookup the class and constructor
+     */
+    proxyClass = (*env)->FindClass(env, BYTE_BUFFER_PROXY_CLASS_NAME);
+    if (proxyClass == NULL) {
+        ASSERT_OUTOFMEM(env);
+        goto finish;
+    }
+    constructor = (*env)->GetMethodID(env, proxyClass,
+                            PLAIN_CONSTRUCTOR,
+                            BYTE_BUFFER_PROXY_CONSTRUCTOR_SIG);
+    if (constructor == NULL) {
+        ASSERT_OUTOFMEM(env);
+        goto finish;
+    }
+
+    /* call the constructor */
+    bufferObj = (*env)->NewObject(env, proxyClass, constructor, pointer);
+
+finish:
+    *buffer = NULL;
+
+    PR_ASSERT(bufferObj || (*env)->ExceptionOccurred(env));
+    return bufferObj;
+}
+
+PRStatus
+JSS_PR_unwrapJByteBuffer(JNIEnv *env, jobject buffer_proxy, j_bytebuffer **buffer)
+{
+    return JSS_getPtrFromProxy(env, buffer_proxy, (void**)buffer);
+}
diff --git a/src/main/java/org/mozilla/jss/nss/ByteBufferProxy.h b/src/main/java/org/mozilla/jss/nss/ByteBufferProxy.h
new file mode 100644
index 000000000..e7d35f776
--- /dev/null
+++ b/src/main/java/org/mozilla/jss/nss/ByteBufferProxy.h
@@ -0,0 +1,10 @@
+#include <jni.h>
+#include "j_bytebuffer.h"
+
+#pragma once
+
+/* Wrap a j_buffer object into a BufferProxy, freeing the buffer on error. */
+jobject JSS_PR_wrapJByteBuffer(JNIEnv *env, j_bytebuffer **buffer);
+
+/* Extract a j_buffer pointer from an instance of a BufferProxy. */
+PRStatus JSS_PR_unwrapJByteBuffer(JNIEnv *env, jobject buffer_proxy, j_bytebuffer **buffer);
diff --git a/src/main/java/org/mozilla/jss/nss/ByteBufferProxy.java b/src/main/java/org/mozilla/jss/nss/ByteBufferProxy.java
new file mode 100644
index 000000000..04a571a76
--- /dev/null
+++ b/src/main/java/org/mozilla/jss/nss/ByteBufferProxy.java
@@ -0,0 +1,25 @@
+package org.mozilla.jss.nss;
+
+import java.nio.ByteBuffer;
+
+public class ByteBufferProxy extends org.mozilla.jss.util.NativeProxy {
+    protected ByteBuffer last;
+
+    public ByteBufferProxy(byte[] pointer) {
+        super(pointer);
+    }
+
+    /**
+     * It is usually better to call org.mozilla.jss.nss.JByteBuffer.Free(...)
+     * instead.
+     *
+     * But this does it for you.
+     */
+    protected void releaseNativeResources() {
+        JByteBuffer.Free(this);
+    }
+
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+}
diff --git a/src/main/java/org/mozilla/jss/nss/JByteBuffer.c b/src/main/java/org/mozilla/jss/nss/JByteBuffer.c
new file mode 100644
index 000000000..5c02ce0a3
--- /dev/null
+++ b/src/main/java/org/mozilla/jss/nss/JByteBuffer.c
@@ -0,0 +1,89 @@
+#include <nspr.h>
+#include <limits.h>
+#include <stdint.h>
+#include <jni.h>
+
+#include "jssutil.h"
+#include "ByteBufferProxy.h"
+#include "j_bytebuffer.h"
+
+#include "_jni/org_mozilla_jss_nss_JByteBuffer.h"
+
+JNIEXPORT jobject JNICALL
+Java_org_mozilla_jss_nss_JByteBuffer_Create(JNIEnv *env, jclass clazz,
+    jboolean writable)
+{
+    j_bytebuffer *buf = NULL;
+
+    PR_ASSERT(env != NULL);
+
+    buf = jbb_alloc(writable == JNI_TRUE);
+
+    PR_ASSERT(buf != NULL);
+
+    return JSS_PR_wrapJByteBuffer(env, &buf);
+}
+
+JNIEXPORT jint JNICALL
+Java_org_mozilla_jss_nss_JByteBuffer_ClearBufferNative(JNIEnv *env,
+    jclass clazz, jobject proxy, jbyteArray last)
+{
+    j_bytebuffer *buf = NULL;
+
+    PR_ASSERT(env != NULL && proxy != NULL);
+
+    if (JSS_PR_unwrapJByteBuffer(env, proxy, &buf) != PR_SUCCESS) {
+        return 0;
+    }
+
+    return jbb_clear_buffer(buf, env, last);
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_mozilla_jss_nss_JByteBuffer_SetBufferNative(JNIEnv *env,
+    jclass clazz, jobject proxy, jbyteArray array, jlong offset,
+    jlong limit)
+{
+    j_bytebuffer *buf = NULL;
+
+    PR_ASSERT(env != NULL && proxy != NULL);
+
+    if (JSS_PR_unwrapJByteBuffer(env, proxy, &buf) != PR_SUCCESS ||
+            buf == NULL) {
+        return JNI_FALSE;
+    }
+
+    return jbb_set_buffer(buf, env, array, offset, limit);
+}
+
+JNIEXPORT jint JNICALL
+Java_org_mozilla_jss_nss_JByteBuffer_Capacity(JNIEnv *env,
+    jclass clazz, jobject proxy)
+{
+    j_bytebuffer *buf = NULL;
+
+    PR_ASSERT(env != NULL && proxy != NULL);
+
+    if (JSS_PR_unwrapJByteBuffer(env, proxy, &buf) != PR_SUCCESS) {
+        return 0;
+    }
+
+    return jbb_capacity(buf);
+}
+
+JNIEXPORT void JNICALL
+Java_org_mozilla_jss_nss_JByteBuffer_FreeNative(JNIEnv *env, jclass clazz,
+    jobject proxy)
+{
+    j_bytebuffer *buf = NULL;
+
+    PR_ASSERT(env != NULL && proxy != NULL);
+
+    if (JSS_PR_unwrapJByteBuffer(env, proxy, &buf) != PR_SUCCESS ||
+            buf == NULL) {
+        return;
+    }
+
+    jbb_free(buf, env);
+    JSS_clearPtrFromProxy(env, proxy);
+}
diff --git a/src/main/java/org/mozilla/jss/nss/JByteBuffer.java b/src/main/java/org/mozilla/jss/nss/JByteBuffer.java
new file mode 100644
index 000000000..de6f8eb39
--- /dev/null
+++ b/src/main/java/org/mozilla/jss/nss/JByteBuffer.java
@@ -0,0 +1,97 @@
+package org.mozilla.jss.nss;
+
+import java.nio.ByteBuffer;
+
+public class JByteBuffer {
+    /**
+     * Create a new j_buffer object with the specified number of bytes.
+     *
+     * See also: jbb_alloc in org/mozilla/jss/ssl/javax/j_bytebuffer.h
+     */
+    public static native ByteBufferProxy Create(boolean writable);
+
+    /**
+     * Removes the existing ByteBuffer from this proxy instance.
+     *
+     * See also: jbb_clear_buffer in org/mozilla/jss/ssl/javax/j_bytebuffer.h
+     */
+    public static int ClearBuffer(ByteBufferProxy proxy) {
+        if (proxy == null || proxy.last == null) {
+            return 0;
+        }
+
+        int offset = ClearBufferNative(proxy, proxy.last.array());
+        proxy.last.position(proxy.last.position() + offset);
+
+        proxy.last = null;
+
+        return offset;
+    }
+
+    /**
+     * Set the underlying buffer for this ByteBufferProxy instance.
+     *
+     * See also: jbb_set_buffer in org/mozilla/jss/ssl/javax/j_bytebuffer.h
+     */
+    public static void SetBuffer(ByteBufferProxy proxy, ByteBuffer buffer) {
+        if (proxy == null) {
+            return;
+        }
+
+        if (buffer != null && !buffer.hasArray()) {
+            String msg = "Unable to support ByteBuffers which are not backed ";
+            msg += "by real arrays.";
+            throw new RuntimeException(msg);
+        }
+
+        if (proxy.last != null) {
+            // This is an unusual case. We should always clear the last buffer
+            // prior to attempting to set a new one. Luckily, we store the
+            // last buffer, so we can clean up safely.
+            ClearBuffer(proxy);
+        }
+
+        if (!SetBufferNative(proxy, buffer.array(), buffer.position(), buffer.limit())) {
+            throw new RuntimeException("Unable to set bufer for an unknown reason.");
+        }
+
+        proxy.last = buffer;
+    }
+
+    /**
+     * Get the remaining capacity of this buffer.
+     *
+     * See also: jbb_capacity in org/mozilla/jss/ssl/javax/j_bytebuffer.h
+     */
+    public static native int Capacity(ByteBufferProxy proxy);
+
+    /**
+     * Clear the underlying buffer for this ByteBufferProxy instance.
+     */
+    private static native int ClearBufferNative(ByteBufferProxy proxy, byte[] last);
+
+    /**
+     * Internal helper to implement the native portion of SetBuffer.
+     *
+     * See also: jbb_set_buffer in org/mozilla/jss/ssl/javax/j_bytebuffer.h
+     */
+    private static native boolean SetBufferNative(ByteBufferProxy proxy, byte[] array, long offset, long limit);
+
+    /**
+     * Destroy a buffer object, freeing its resources.
+     *
+     * See also: jbb_free in org/mozilla/jss/ssl/javax/j_buffer.h
+     */
+    public static void Free(ByteBufferProxy proxy) {
+        // Make sure we call ClearBuffer ourselves; otherwise, any changes to
+        // the underlying ByteBuffer won't be reflected as FreeNative will
+        // discard them.
+        ClearBuffer(proxy);
+        FreeNative(proxy);
+    }
+
+    /**
+     * Internal helper to implement the free call.
+     */
+    private static native void FreeNative(ByteBufferProxy proxy);
+}
diff --git a/src/main/java/org/mozilla/jss/nss/PR.c b/src/main/java/org/mozilla/jss/nss/PR.c
index de7825f83..f3bc01091 100644
--- a/src/main/java/org/mozilla/jss/nss/PR.c
+++ b/src/main/java/org/mozilla/jss/nss/PR.c
@@ -7,7 +7,9 @@
 #include "jss_exceptions.h"
 #include "PRFDProxy.h"
 #include "BufferProxy.h"
+#include "ByteBufferProxy.h"
 #include "BufferPRFD.h"
+#include "ByteBufferPRFD.h"
 
 #include "_jni/org_mozilla_jss_nss_PR.h"
 
@@ -102,7 +104,7 @@ Java_org_mozilla_jss_nss_PR_Close(JNIEnv *env, jclass clazz, jobject fd, jboolea
         return PR_SUCCESS;
     }
 
-    if (JSS_PR_getPRFileDesc(env, fd, &real_fd) != PR_SUCCESS) {
+    if (JSS_PR_getPRFileDesc(env, fd, &real_fd) != PR_SUCCESS || real_fd == NULL) {
         return PR_FAILURE;
     }
 
@@ -114,6 +116,44 @@ Java_org_mozilla_jss_nss_PR_Close(JNIEnv *env, jclass clazz, jobject fd, jboolea
     return ret;
 }
 
+JNIEXPORT jobject JNICALL
+Java_org_mozilla_jss_nss_PR_NewByteBufferPRFD(JNIEnv *env, jclass clazz,
+    jobject read_buf, jobject write_buf, jbyteArray peer_info)
+{
+    j_bytebuffer *real_read_buf = NULL;
+    j_bytebuffer *real_write_buf = NULL;
+    uint8_t *real_peer_info = NULL;
+    size_t peer_info_len = 0;
+
+    PRFileDesc *buf_prfd;
+    jobject result = NULL;
+
+    PR_ASSERT(env != NULL && read_buf != NULL && write_buf != NULL);
+    PR_SetError(0, 0);
+
+    if (JSS_PR_unwrapJByteBuffer(env, read_buf, &real_read_buf) != PR_SUCCESS) {
+        return result;
+    }
+
+    if (JSS_PR_unwrapJByteBuffer(env, write_buf, &real_write_buf) != PR_SUCCESS) {
+        return result;
+    }
+
+    if (peer_info != NULL && !JSS_FromByteArray(env, peer_info, &real_peer_info, &peer_info_len)) {
+        return result;
+    }
+
+    buf_prfd = newByteBufferPRFileDesc(real_read_buf, real_write_buf,
+        real_peer_info, peer_info_len);
+    if (buf_prfd == NULL) {
+        return result;
+    }
+
+    result = JSS_PR_wrapPRFDProxy(env, &buf_prfd);
+    free(real_peer_info);
+    return result;
+}
+
 JNIEXPORT int JNICALL
 Java_org_mozilla_jss_nss_PR_Shutdown(JNIEnv *env, jclass clazz, jobject fd,
     jint how)
@@ -127,7 +167,7 @@ Java_org_mozilla_jss_nss_PR_Shutdown(JNIEnv *env, jclass clazz, jobject fd,
         return PR_SUCCESS;
     }
 
-    if (JSS_PR_getPRFileDesc(env, fd, &real_fd) != PR_SUCCESS) {
+    if (JSS_PR_getPRFileDesc(env, fd, &real_fd) != PR_SUCCESS || real_fd == NULL) {
         return PR_FAILURE;
     }
 
@@ -149,7 +189,7 @@ Java_org_mozilla_jss_nss_PR_Read(JNIEnv *env, jclass clazz, jobject fd,
     PR_ASSERT(env != NULL && fd != NULL && amount >= 0);
     PR_SetError(0, 0);
 
-    if (JSS_PR_getPRFileDesc(env, fd, &real_fd) != PR_SUCCESS) {
+    if (JSS_PR_getPRFileDesc(env, fd, &real_fd) != PR_SUCCESS || real_fd == NULL) {
         return NULL;
     }
 
@@ -221,7 +261,7 @@ Java_org_mozilla_jss_nss_PR_Write(JNIEnv *env, jclass clazz, jobject fd,
     PR_ASSERT(env != NULL && fd != NULL);
     PR_SetError(0, 0);
 
-    if (JSS_PR_getPRFileDesc(env, fd, &real_fd) != PR_SUCCESS) {
+    if (JSS_PR_getPRFileDesc(env, fd, &real_fd) != PR_SUCCESS || real_fd == NULL) {
         return 0;
     }
 
@@ -263,7 +303,7 @@ Java_org_mozilla_jss_nss_PR_Recv(JNIEnv *env, jclass clazz, jobject fd,
               timeout >= 0 && timeout <= UINT32_MAX);
     PR_SetError(0, 0);
 
-    if (JSS_PR_getPRFileDesc(env, fd, &real_fd) != PR_SUCCESS) {
+    if (JSS_PR_getPRFileDesc(env, fd, &real_fd) != PR_SUCCESS || real_fd == NULL) {
         return NULL;
     }
 
@@ -298,7 +338,7 @@ Java_org_mozilla_jss_nss_PR_Send(JNIEnv *env, jclass clazz, jobject fd,
               timeout >= 0 && timeout <= UINT32_MAX);
     PR_SetError(0, 0);
 
-    if (JSS_PR_getPRFileDesc(env, fd, &real_fd) != PR_SUCCESS) {
+    if (JSS_PR_getPRFileDesc(env, fd, &real_fd) != PR_SUCCESS || real_fd == NULL) {
         return 0;
     }
 
diff --git a/src/main/java/org/mozilla/jss/nss/PR.java b/src/main/java/org/mozilla/jss/nss/PR.java
index 90e770e83..6e80f4b72 100644
--- a/src/main/java/org/mozilla/jss/nss/PR.java
+++ b/src/main/java/org/mozilla/jss/nss/PR.java
@@ -65,6 +65,17 @@ public class PR {
     public static native PRFDProxy NewBufferPRFD(BufferProxy read_buf,
                                                  BufferProxy write_buf,
                                                  byte[] peer_info);
+
+    /**
+     * Create a new j_bytebuffer backed PRFileDesc, mimicing a TCP socket with
+     * the specified peer_info.
+     *
+     * See also: newByteBufferPRFileDesc in org/mozilla/jss/ssl/javax/ByteBufferPRFD.h
+     */
+    public static native PRFDProxy NewByteBufferPRFD(ByteBufferProxy read_buf,
+                                                     ByteBufferProxy write_buf,
+                                                     byte[] peer_info);
+
     /**
      * Close an existing PRFDProxy, clearing the pointer if successful.
      *
diff --git a/src/main/java/org/mozilla/jss/provider/javax/net/JSSContextSpi.java b/src/main/java/org/mozilla/jss/provider/javax/net/JSSContextSpi.java
index e834c554e..670ee0ea6 100644
--- a/src/main/java/org/mozilla/jss/provider/javax/net/JSSContextSpi.java
+++ b/src/main/java/org/mozilla/jss/provider/javax/net/JSSContextSpi.java
@@ -10,7 +10,7 @@
 
 import org.mozilla.jss.provider.javax.crypto.JSSKeyManager;
 import org.mozilla.jss.ssl.javax.JSSEngine;
-import org.mozilla.jss.ssl.javax.JSSEngineReferenceImpl;
+import org.mozilla.jss.ssl.javax.JSSEngineOptimizedImpl;
 import org.mozilla.jss.ssl.javax.JSSParameters;
 import org.mozilla.jss.ssl.javax.JSSServerSocketFactory;
 import org.mozilla.jss.ssl.javax.JSSSocketFactory;
@@ -53,7 +53,7 @@ public void engineInit(KeyManager[] kms, TrustManager[] tms, SecureRandom sr) th
     public SSLEngine engineCreateSSLEngine() {
         logger.debug("JSSContextSpi.engineCreateSSLEngine()");
 
-        JSSEngine ret = new JSSEngineReferenceImpl();
+        JSSEngine ret = new JSSEngineOptimizedImpl();
         initializeEngine(ret);
 
         return ret;
@@ -63,7 +63,7 @@ public SSLEngine engineCreateSSLEngine() {
     public SSLEngine engineCreateSSLEngine(String host, int port) {
         logger.debug("JSSContextSpi.engineCreateSSLEngine(" + host + ", " + port + ")");
 
-        JSSEngine ret = new JSSEngineReferenceImpl(host, port);
+        JSSEngine ret = new JSSEngineOptimizedImpl(host, port);
         initializeEngine(ret);
 
         return ret;
diff --git a/src/main/java/org/mozilla/jss/ssl/javax/BufferPRFD.h b/src/main/java/org/mozilla/jss/ssl/javax/BufferPRFD.h
index 74c8ba208..8dce4d6ef 100644
--- a/src/main/java/org/mozilla/jss/ssl/javax/BufferPRFD.h
+++ b/src/main/java/org/mozilla/jss/ssl/javax/BufferPRFD.h
@@ -12,14 +12,6 @@
 /* Use a modern pragma guard... */
 #pragma once
 
-/* Free a Buffer-backed PRFileDesc. Note that it is usually sufficient to call
- * PR_Close(...) on the buffer instead. This is provided for completeness and
- * should not be called in a SSL context as the buffer PRFileDesc is wrapped
- * by the SSL PRFileDesc. Note that this only removes references to the
- * underlying j_buffers and does not free them; it is up to the caller to
- * do so. */
-void freeBufferPRFileDesc(PRFileDesc *fd);
-
 /* Construct a new PRFileDesc backed by a pair of buffers. Note that these
  * should be separate buffers, but need not be unique to this PRFileDesc;
  * that is, a client and server could share (but be swapped) j_buffers.
diff --git a/src/main/java/org/mozilla/jss/ssl/javax/ByteBufferPRFD.c b/src/main/java/org/mozilla/jss/ssl/javax/ByteBufferPRFD.c
new file mode 100644
index 000000000..1649aead2
--- /dev/null
+++ b/src/main/java/org/mozilla/jss/ssl/javax/ByteBufferPRFD.c
@@ -0,0 +1,350 @@
+#include <nspr.h>
+
+/* Necessary for correctly propagating E_WOULDBLOCK. */
+#include <errno.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+/* Ring buffer implementation to handle read/write calls. */
+#include "j_bytebuffer.h"
+#include "ByteBufferPRFD.h"
+
+/* This struct stores all the private data we need access to from inside our
+ * PRFileDesc calls. We store the following information:
+ *
+ *      read_buffer -- raw buffer to read from for recv(...) calls
+ *
+ *      write_buffer -- raw buffer to write to for send(...) calls
+ *
+ *      peer_addr -- peer address info, truncated to 16 bytes
+ *
+ * As the read_* and write_* members should be provided by the creator, and
+ * actors outside our PRFileDesc need access to this information (to add more
+ * bytes to the read buffer when more data arrives for instance), we store
+ * pointers and not the values themselves.
+ *
+ * The creator is responsible for ensuring that all data gets correctly freed
+ * when the program exits; we will not free any of our pointers that were not
+ * created by us.
+ */
+struct PRFilePrivate {
+    j_bytebuffer *read_buffer;
+    j_bytebuffer *write_buffer;
+
+    uint8_t *peer_addr;
+};
+
+static PRDescIdentity byte_buffer_layer_id = 0;
+
+// This function is provided as a stub for all unimplemented calls.
+static PRIntn invalidInternalCall(/* anything */)
+{
+    // For debugging; any invalid calls are asserted, so we can get a full
+    // backtrace from the debugger and _hopefully_ we can find out which call
+    // was attempted. To enable asserts, define DEBUG or FORCE_PR_ASSERT
+    // before loading the NSPR headers, e.g., by using the DEBUG release type
+    // during CMake configuration time.
+    PR_ASSERT(!"invalidInternalCall performed!");
+    return 0;
+}
+
+// This function mimics shutting down a buffer.
+static PRStatus PRByteBufferShutdown(PRFileDesc *fd, PRIntn how)
+{
+    // This method has no functionality; we're a lower level under both
+    // the SSLEngine and NSS's SSL context. When the application issues
+    // a shutdown request, SSLEngine refuses to allow new writes (and only
+    // reads until the remote party acknowledges the shutdown). All data
+    // should be written into the NSS connection buffer and NSS's shutdown
+    // should be called. At this point, there's nothing left for us to do:
+    // there's no TCP socket we need to terminate, and we need to allow
+    // any remaining buffered bytes to be written. So, the only thing we
+    // can do is return success here.
+    return PR_SUCCESS;
+}
+
+// This function mimics closing a buffer and frees our associated data.
+static PRStatus PRByteBufferClose(PRFileDesc *fd)
+{
+    PRStatus rv = PR_SUCCESS;
+
+    if (fd->secret != NULL) {
+        // We intentionally don't free read_buffer or write_buffer; we assume
+        // the caller has a copy of these data structures as well, and could
+        // still be reading after the PRFileDesc is closed.
+        fd->secret->read_buffer = NULL;
+        fd->secret->write_buffer = NULL;
+
+        // Free the peer address we allocated during initialiation.
+        free(fd->secret->peer_addr);
+        fd->secret->peer_addr = NULL;
+
+        // Free our internal data structure.
+        free(fd->secret);
+        fd->secret = NULL;
+    }
+
+    PR_ASSERT(fd->identity == byte_buffer_layer_id);
+    PR_ASSERT(fd->higher == NULL);
+    PR_ASSERT(fd->lower == NULL);
+
+    return rv;
+}
+
+// Fake getting the name of the remote peer
+static PRStatus PRByteBufferGetPeerName(PRFileDesc *fd, PRNetAddr *addr)
+{
+    /* getPeerName takes a PRFileDesc and modifies the PRNetAddr with the
+     * name of the peer. Because of the specifics of the NSS Implementation,
+     * we return whatever name was passed to us on creation; we lack a real
+     * TCP socket and thus a real TCP name.
+     *
+     * However, we have to provide the peer name as type IPv6, else it either
+     * gets mangled by the IPv4 -> IPv6 translation or a
+     * PR_ADDRESS_NOT_SUPPORTED_ERROR is thrown by ssl_GetPeerInfo(...).
+     */
+
+    /* There are three main places this is called in a normal TLS connection:
+     *
+     *      ssl_ImportFD(...) -- where the result of this function is compared
+     *                           to PR_SUCCESS to see if it is connected
+     *      ssl_BeginClientHandshake(...) -- where this function sets local
+     *                                       values for session resumption on
+     *                                       the client
+     *      ssl3_HandleClientHello(...) -- where this function sets local
+     *                                     values for evaluating session
+     *                                     resumption from the client.
+     *
+     * Because these results have to be consistent for session resumption to
+     * work, we must query the internal structure and return that value.
+     * Note that it isn't a security risk if an incorrect peer_addr is
+     * provided to us: the other party must _also_ know the session keys for
+     * this to matter.
+     */
+
+    // https://developer.mozilla.org/en-US/docs/Mozilla/Projects/NSPR/Reference/PRNetAddr
+    if (fd->secret == NULL || addr == NULL) {
+        return PR_FAILURE;
+    }
+
+    PRFilePrivate *internal = fd->secret;
+    addr->ipv6.family = PR_AF_INET6;
+    addr->ipv6.port = 0xFFFF;
+    addr->ipv6.flowinfo = 0x00000000;
+
+    // We validate that strlen(peer_addr) <= 16 on creation by truncating
+    // it to 16 bytes. Thus the memcpy with strlen(...) won't overflow the
+    // size of ipv6.ip.
+    memset(&addr->ipv6.ip, 0, 16);
+    memcpy(&addr->ipv6.ip, internal->peer_addr, 16);
+    return PR_SUCCESS;
+}
+
+// Respond to send requests
+static PRInt32 PRByteBufferSend(PRFileDesc *fd, const void *buf, PRInt32 amount,
+        PRIntn flags, PRIntervalTime timeout)
+{
+    /* Send takes a PRFileDesc and attempts to send some amount of bytes from
+     * the start of buf to the other party before timeout is reached. Because
+     * we're implementing this as a buffer, copy into the buffer if there is
+     * free space, else return EWOULDBLOCK.  */
+
+    PRFilePrivate *internal = fd->secret;
+
+    /* Prefer the initial write call. */
+    PRInt32 this_write = jbb_write(internal->write_buffer, (const uint8_t *) buf, amount);
+
+    if (this_write == 0) {
+        /* Under correct Unix non-blocking socket semantics, if we lack data
+         * to write, return a negative length and set EWOULDBLOCK. This is
+         * documented in `man 2 recv`. */
+        PR_SetError(PR_WOULD_BLOCK_ERROR, EWOULDBLOCK);
+        return -1;
+    }
+
+    return this_write;
+}
+
+// Respond to write requests
+static PRInt32 PRByteBufferWrite(PRFileDesc *fd, const void *buf, PRInt32 amount)
+{
+    /* Write is the same as Send except that it doesn't have a timeout or
+     * understand flags. Since our implementation of Send is fake, pass
+     * arbitrary data and use it to implement Write as well. */
+    return PRByteBufferSend(fd, buf, amount, 0, -1);
+}
+
+
+// Respond to recv requests
+static PRInt32 PRByteBufferRecv(PRFileDesc *fd, void *buf, PRInt32 amount, PRIntn flags, PRIntervalTime timeout)
+{
+    /* Recv takes a PRFileDesc and attempts to read some amount of bytes from
+     * the start of buf to return to the caller before timeout is reached.
+     * Because we're implementing this as a buffer, copy from the buffer when
+     * there is something in it, else return EWOULDBLOCK. */
+    PRFilePrivate *internal = fd->secret;
+
+    PRInt32 this_read = jbb_read(internal->read_buffer, (uint8_t *) buf, amount);
+    if (this_read == 0) {
+        /* See comment in PRByteBufferSend about EWOULDBLOCK. */
+        PR_SetError(PR_WOULD_BLOCK_ERROR, EWOULDBLOCK);
+        return -1;
+    }
+
+    return this_read;
+}
+
+// Respond to read requests
+static PRInt32 PRByteBufferRead(PRFileDesc *fd, void *buf, PRInt32 amount)
+{
+    /* Read is the same as Recv except that it doesn't have a timeout or
+     * understand flags. Since our implementation of Recv is fake, pass
+     * arbitrary data and use it to implement Read as well. */
+    return PRByteBufferRecv(fd, buf, amount, 0, -1);
+}
+
+// Fake responses to getSocketOption requests
+static PRStatus PRByteBufferGetSocketOption(PRFileDesc *fd, PRSocketOptionData *data)
+{
+    /* getSocketOption takes a PRFileDesc and modifies the value field of data
+     * with socket option specified in the option field. We fake responses with
+     * a couple of sane defaults here:
+     *
+     *   non_blocking = true
+     *   reuse_addr = true
+     *   keep_alive = false
+     *   no_delay = true
+     *
+     * We return valid responses to three other options:
+     *
+     *   max_segment = capacity of read_buffer
+     *   recv_buffer_size = capacity of read buffer
+     *   send_buffer_size = capacity of write buffer
+     *
+     * Note that all responses are "fake" in that calls to SetSocketOption will
+     * not be reflected here.
+     */
+
+    if (!data || !fd) {
+        return PR_FAILURE;
+    }
+
+    PRFilePrivate *internal = fd->secret;
+    size_t read_capacity = jbb_capacity(internal->read_buffer);
+    size_t write_capacity = jbb_capacity(internal->write_buffer);
+    size_t max_segment = read_capacity;
+    if (write_capacity > max_segment) {
+        max_segment = write_capacity;
+    }
+
+    switch (data->option) {
+    case PR_SockOpt_Nonblocking:
+        data->value.non_blocking = PR_TRUE;
+        return PR_SUCCESS;
+    case PR_SockOpt_Reuseaddr:
+        data->value.reuse_addr = PR_TRUE;
+        return PR_SUCCESS;
+    case PR_SockOpt_Keepalive:
+        data->value.keep_alive = PR_FALSE;
+        return PR_SUCCESS;
+    case PR_SockOpt_NoDelay:
+        data->value.no_delay = PR_TRUE;
+        return PR_SUCCESS;
+    case PR_SockOpt_MaxSegment:
+        data->value.max_segment = max_segment;
+        return PR_SUCCESS;
+    case PR_SockOpt_RecvBufferSize:
+        data->value.recv_buffer_size = read_capacity;
+        return PR_SUCCESS;
+    case PR_SockOpt_SendBufferSize:
+        data->value.send_buffer_size = write_capacity;
+        return PR_SUCCESS;
+    default:
+        return PR_FAILURE;
+    }
+}
+
+// Fake responses to setSocketOption
+static PRStatus PRByteBufferSetSocketOption(PRFileDesc *fd, const PRSocketOptionData *data)
+{
+    /* This gives the caller control over setting socket options. It is the
+     * equivalent of fcntl() with F_SETFL. In our case, O_NONBLOCK is the
+     * only thing passed in, which we always return as true anyways, so
+     * ignore the result. */
+    return PR_SUCCESS;
+}
+
+// Create a method table with all our implemented functions
+static const PRIOMethods PRIOByteBufferMethods = {
+    PR_DESC_SOCKET_TCP,
+    PRByteBufferClose,
+    PRByteBufferRead,
+    PRByteBufferWrite,
+    (PRAvailableFN)invalidInternalCall,
+    (PRAvailable64FN)invalidInternalCall,
+    (PRFsyncFN)invalidInternalCall,
+    (PRSeekFN)invalidInternalCall,
+    (PRSeek64FN)invalidInternalCall,
+    (PRFileInfoFN)invalidInternalCall,
+    (PRFileInfo64FN)invalidInternalCall,
+    (PRWritevFN)invalidInternalCall,
+    (PRConnectFN)invalidInternalCall,
+    (PRAcceptFN)invalidInternalCall,
+    (PRBindFN)invalidInternalCall,
+    (PRListenFN)invalidInternalCall,
+    PRByteBufferShutdown,
+    PRByteBufferRecv,
+    PRByteBufferSend,
+    (PRRecvfromFN)invalidInternalCall,
+    (PRSendtoFN)invalidInternalCall,
+    (PRPollFN)invalidInternalCall,
+    (PRAcceptreadFN)invalidInternalCall,
+    (PRTransmitfileFN)invalidInternalCall,
+    (PRGetsocknameFN)invalidInternalCall,
+    PRByteBufferGetPeerName,
+    (PRReservedFN)invalidInternalCall,
+    (PRReservedFN)invalidInternalCall,
+    PRByteBufferGetSocketOption,
+    PRByteBufferSetSocketOption,
+    (PRSendfileFN)invalidInternalCall,
+    (PRConnectcontinueFN)invalidInternalCall,
+    (PRReservedFN)invalidInternalCall,
+    (PRReservedFN)invalidInternalCall,
+    (PRReservedFN)invalidInternalCall,
+    (PRReservedFN)invalidInternalCall
+};
+
+/* Construct a new PRFileDesc backed by a pair of buffers. Note that these
+ * should be separate buffers, but need not be unique to this PRFileDesc;
+ * that is, a client and server could share (but be swapped) j_bytebuffers.
+ * The caller is expected to provide a peer_info to be used for optional
+ * session resumption; this will be truncated at 16 bytes of data, and
+ * extended with nulls if it is shorter. It is suggested that this be an IPv4
+ * or IPv6 address. Note that this value is not used to validate the hostname
+ * in any way (see SSL_SetURL to validate the peer). */
+PRFileDesc *newByteBufferPRFileDesc(j_bytebuffer *read_buf, j_bytebuffer *write_buf,
+    uint8_t *peer_info, size_t peer_info_len)
+{
+    PRFileDesc *fd;
+
+    if (byte_buffer_layer_id == 0) {
+        byte_buffer_layer_id = PR_GetUniqueIdentity("ByteBuffer");
+    }
+
+    fd = PR_CreateIOLayerStub(byte_buffer_layer_id, &PRIOByteBufferMethods);
+    if (fd) {
+        fd->secret = PR_NEW(PRFilePrivate);
+
+        fd->secret->read_buffer = read_buf;
+        fd->secret->write_buffer = write_buf;
+
+        size_t len = peer_info_len;
+        if (len > 16) { len = 16; }
+
+        fd->secret->peer_addr = calloc(16, sizeof(uint8_t));
+        memcpy(fd->secret->peer_addr, peer_info, len);
+    }
+
+    return fd;
+}
diff --git a/src/main/java/org/mozilla/jss/ssl/javax/ByteBufferPRFD.h b/src/main/java/org/mozilla/jss/ssl/javax/ByteBufferPRFD.h
new file mode 100644
index 000000000..f7cb8c6f4
--- /dev/null
+++ b/src/main/java/org/mozilla/jss/ssl/javax/ByteBufferPRFD.h
@@ -0,0 +1,24 @@
+#include <nspr.h>
+
+/* Necessary for correctly propagating E_WOULDBLOCK. */
+#include <errno.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+/* Ring buffer implementation to handle read/write calls. */
+#include "j_bytebuffer.h"
+
+/* Use a modern pragma guard... */
+#pragma once
+
+/* Construct a new PRFileDesc backed by a pair of ByteBuffers. Note that these
+ * should be separate buffers, but need not be unique to this PRFileDesc;
+ * that is, a client and server could share (but be swapped) j_bytebuffers.
+ * The caller is expected to provide a peer_info to be used for optional
+ * session resumption; this will be truncated at 16 bytes of data, and
+ * extended with nulls if it is shorter. It is suggested that this be an IPv4
+ * or IPv6 address. Note that this value is not used to validate the hostname
+ * in any way (see SSL_SetURL to validate the peer). */
+PRFileDesc *newByteBufferPRFileDesc(j_bytebuffer *read_buf, j_bytebuffer *write_buf,
+    uint8_t *peer_info, size_t peer_info_len);
diff --git a/src/main/java/org/mozilla/jss/ssl/javax/JSSEngineOptimizedImpl.java b/src/main/java/org/mozilla/jss/ssl/javax/JSSEngineOptimizedImpl.java
new file mode 100644
index 000000000..091f10731
--- /dev/null
+++ b/src/main/java/org/mozilla/jss/ssl/javax/JSSEngineOptimizedImpl.java
@@ -0,0 +1,1409 @@
+package org.mozilla.jss.ssl.javax;
+
+import java.lang.*;
+import java.util.*;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.nio.channels.WritableByteChannel;
+import java.nio.channels.Channels;
+import java.security.PublicKey;
+import java.security.cert.CertificateException;
+
+import java.nio.ByteBuffer;
+
+import javax.net.ssl.*;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.mozilla.jss.nss.*;
+import org.mozilla.jss.pkcs11.*;
+import org.mozilla.jss.provider.javax.crypto.*;
+import org.mozilla.jss.ssl.*;
+
+import org.mozilla.jss.crypto.Policy;
+import org.mozilla.jss.crypto.PrivateKey;
+import org.mozilla.jss.crypto.X509Certificate;
+
+/**
+ * An optimized JSSEngine implementation.
+ *
+ * This JSSEngine implementation is optimized for lower JNI overhead when
+ * compared to the reference implementation.
+ */
+public class JSSEngineOptimizedImpl extends JSSEngine {
+    private String peer_info;
+
+    private boolean closed_fd = true;
+    private ByteBufferProxy read_buf;
+    private ByteBufferProxy write_buf;
+
+    private int unknown_state_count;
+    private boolean step_handshake;
+
+    private SSLException ssl_exception;
+    private boolean seen_exception;
+
+    private CertValidationTask task;
+
+    public JSSEngineOptimizedImpl() {
+        super();
+
+        peer_info = "";
+
+        logger.debug("JSSEngine: constructor()");
+    }
+
+    public JSSEngineOptimizedImpl(String peerHost, int peerPort) {
+        super(peerHost, peerPort);
+
+        peer_info = peerHost + ":" + peerPort;
+
+        logger.debug("JSSEngine: constructor(" + peerHost + ", " + peerPort + ")");
+    }
+
+    public JSSEngineOptimizedImpl(String peerHost, int peerPort,
+                     org.mozilla.jss.crypto.X509Certificate localCert,
+                     org.mozilla.jss.crypto.PrivateKey localKey) {
+        super(peerHost, peerPort, localCert, localKey);
+
+        peer_info = peerHost + ":" + peerPort;
+
+        logger.debug("JSSEngine: constructor(" + peerHost + ", " + peerPort + ", " + localCert + ", " + localKey + ")");
+    }
+
+    private void init() throws SSLException {
+        logger.debug("JSSEngine: init()");
+
+        // Initialize our JSSEngine when we begin to handshake; otherwise,
+        // calls to Set<Option>(...) won't be processed if we call it too
+        // early; some of these need to be applied at initialization.
+
+        // Ensure we don't leak ssl_fd if we're called multiple times.
+        if (ssl_fd != null && !closed_fd) {
+            is_inbound_closed = true;
+            is_outbound_closed = true;
+            cleanup();
+        }
+
+        ssl_fd = null;
+
+        // Create buffers for interacting with NSS.
+        createBuffers();
+        createBufferFD();
+
+        // Initialize the appropriate end of this connection.
+        if (as_server) {
+            initServer();
+        } else {
+            initClient();
+        }
+
+        // Apply the requested cipher suites and protocols.
+        applyProtocols();
+        applyCiphers();
+        applyConfig();
+
+        // Apply hostname information (via setURL).
+        applyHosts();
+
+        // Apply TrustManager(s) information for validating the peer's
+        // certificate.
+        applyTrustManagers();
+    }
+
+    private void createBuffers() {
+        logger.debug("JSSEngine: createBuffers()");
+
+        // If the buffers exist, destroy them and recreate.
+        if (read_buf != null) {
+            JByteBuffer.Free(read_buf);
+        }
+        read_buf = JByteBuffer.Create(false);
+
+        if (write_buf != null) {
+            JByteBuffer.Free(write_buf);
+        }
+        write_buf = JByteBuffer.Create(true);
+    }
+
+    private void createBufferFD() throws SSLException {
+        logger.debug("JSSEngine: createBufferFD()");
+
+        // Create the basis for the ssl_fd from the pair of buffers.
+        PRFDProxy fd;
+        if (peer_info != null && peer_info.length() != 0) {
+            fd = PR.NewByteBufferPRFD(read_buf, write_buf, peer_info.getBytes());
+        } else {
+            fd = PR.NewByteBufferPRFD(read_buf, write_buf, null);
+        }
+
+        if (fd == null) {
+            throw new SSLException("Error creating buffer-backed PRFileDesc.");
+        }
+
+        SSLFDProxy model = null;
+        if (as_server) {
+            model = getServerTemplate(cert, key);
+        }
+
+        // Initialize ssl_fd from the model Buffer-backed PRFileDesc.
+        ssl_fd = SSL.ImportFD(model, fd);
+        closed_fd = false;
+
+        // Turn on SSL Alert Logging for the ssl_fd object.
+        int ret = SSL.EnableAlertLogging(ssl_fd);
+        if (ret == SSL.SECFailure) {
+            throw new SSLException("Unable to enable SSL Alert Logging on this SSLFDProxy instance.");
+        }
+
+        ret = SSL.EnableHandshakeCallback(ssl_fd);
+        if (ret == SSL.SECFailure) {
+            throw new SSLException("Unable to enable SSL Handshake Callback on this SSLFDProxy instance.");
+        }
+
+        // Pass this ssl_fd to the session object so that we can use
+        // SSL methods to invalidate the session.
+    }
+
+    private void initClient() throws SSLException {
+        logger.debug("JSSEngine: initClient()");
+
+        if (cert != null && key != null) {
+            logger.debug("JSSEngine.initClient(): Enabling client auth: " + cert);
+            ssl_fd.SetClientCert(cert);
+            if (SSL.AttachClientCertCallback(ssl_fd) != SSL.SECSuccess) {
+                throw new SSLException("Unable to attach client certificate auth callback.");
+            }
+        }
+    }
+
+    private void initServer() throws SSLException {
+        logger.debug("JSSEngine: initServer()");
+
+        // The only time cert and key are required are when we're creating a
+        // server SSLEngine.
+        if (cert == null || key == null) {
+            throw new IllegalArgumentException("JSSEngine: must be initialized with server certificate and key!");
+        }
+
+        logger.debug("JSSEngine.initServer(): " + cert);
+        logger.debug("JSSEngine.initServer(): " + key);
+
+        session.setLocalCertificates(new PK11Cert[]{ cert } );
+
+        // Create a small session cache.
+        //
+        // TODO: Make this configurable.
+        initializeSessionCache(1, 100, null);
+
+        configureClientAuth();
+    }
+
+    private void configureClientAuth() throws SSLException {
+        logger.debug("SSLFileDesc: " + ssl_fd);
+
+        // Only specify these on the server side as they affect what we
+        // want from the remote peer in NSS. In the server case, this is
+        // client auth, but if we were to set these on the client, it would
+        // affect server auth.
+        if (SSL.OptionSet(ssl_fd, SSL.REQUEST_CERTIFICATE, want_client_auth || need_client_auth ? 1 : 0) == SSL.SECFailure) {
+            throw new SSLException("Unable to configure SSL_REQUEST_CERTIFICATE option: " + errorText(PR.GetError()));
+        }
+
+        if (SSL.OptionSet(ssl_fd, SSL.REQUIRE_CERTIFICATE, need_client_auth ? SSL.REQUIRE_ALWAYS : 0) == SSL.SECFailure) {
+            throw new SSLException("Unable to configure SSL_REQUIRE_CERTIFICATE option: " + errorText(PR.GetError()));
+        }
+    }
+
+    protected void reconfigureClientAuth() {
+        if (ssl_fd == null || !as_server) {
+            return;
+        }
+
+        try {
+            configureClientAuth();
+        } catch (SSLException se) {
+            // We cannot throw SSLException from this helper because it
+            // is called from setNeedClientAuth and setWantClientAuth,
+            // both of which don't disclose SSLException.
+            throw new RuntimeException(se.getMessage(), se);
+        }
+    }
+
+    private void applyCiphers() throws SSLException {
+        logger.debug("JSSEngine: applyCiphers()");
+        // Enabled the ciphersuites specified by setEnabledCipherSuites(...).
+        // When this isn't called, enabled_ciphers will be null, so we'll just
+        // use whatever is enabled by default.
+        if (enabled_ciphers == null) {
+            return;
+        }
+
+        // We need to disable the suite if it isn't present in the list of
+        // suites above. Be lazy about it for the time being and disable all
+        // cipher suites first.
+        for (SSLCipher suite : SSLCipher.values()) {
+            if (SSL.CipherPrefSet(ssl_fd, suite.getID(), false) == SSL.SECFailure) {
+                // logger.warn("Unable to set cipher suite preference for " + suite.name() + ": " + errorText(PR.GetError()));
+            }
+        }
+
+        // Only enable these particular suites. When a cipher suite can't be
+        // enabled it is most likely due to local policy. Log it. Also log
+        // which ciphers were successfully enabled for debugging purposes.
+        for (SSLCipher suite : enabled_ciphers) {
+            if (suite == null) {
+                continue;
+            }
+
+            if (SSL.CipherPrefSet(ssl_fd, suite.getID(), true) == SSL.SECFailure) {
+                logger.warn("Unable to enable cipher suite " + suite + ": " + errorText(PR.GetError()));
+            } else {
+                logger.debug("Enabled cipher suite " + suite + ": " + errorText(PR.GetError()));
+            }
+        }
+    }
+
+    private void applyProtocols() throws SSLException {
+        logger.debug("JSSEngine: applyProtocols() min_protocol=" + min_protocol + " max_protocol=" + max_protocol);
+        // Enable the protocols only when both a maximum and minimum protocol
+        // version are specified.
+        if (min_protocol == null || max_protocol == null) {
+            logger.debug("JSSEngine: applyProtocols() - missing min_protocol or max_protocol; using defaults");
+            return;
+        }
+
+        // We should bound this range by crypto-policies in the future to
+        // match the current behavior.
+        SSLVersionRange vrange = new SSLVersionRange(min_protocol, max_protocol);
+        if (SSL.VersionRangeSet(ssl_fd, vrange) == SSL.SECFailure) {
+            throw new SSLException("Unable to set version range: " + errorText(PR.GetError()));
+        }
+    }
+
+    private void applyConfig() throws SSLException {
+        logger.debug("JSSEngine: applyConfig()");
+        for (Integer key : config.keySet()) {
+            Integer value = config.get(key);
+
+            logger.debug("Setting configuration option: " + key + "=" + value);
+            if (SSL.OptionSet(ssl_fd, key, value) != SSL.SECSuccess) {
+                throw new SSLException("Unable to set configuration value: " + key + "=" + value);
+            }
+        }
+    }
+
+    private void applyHosts() throws SSLException {
+        logger.debug("JSSEngine: applyHosts()");
+
+        // This is most useful for the client end of the connection; this
+        // specifies what to match the server's certificate against.
+        if (hostname != null) {
+            if (SSL.SetURL(ssl_fd, hostname) == SSL.SECFailure) {
+                throw new SSLException("Unable to configure server hostname: " + errorText(PR.GetError()));
+            }
+        }
+    }
+
+    private void applyTrustManagers() throws SSLException {
+        logger.debug("JSSEngine: applyTrustManagers()");
+
+        // If none have been specified, exit early.
+        if (trust_managers == null || trust_managers.length == 0) {
+            // Use the default NSS certificate authentication handler. We
+            // don't need to do anything to use it.
+            logger.debug("JSSEngine: no TrustManagers to apply.");
+            return;
+        }
+
+        // Determine which configuration to use for checking certificates. Our
+        // options are a Native trust manager (most performant) or using a set
+        // of X509TrustManagers.
+        if (trust_managers.length == 1 && trust_managers[0] instanceof JSSNativeTrustManager) {
+            // This is a dummy TrustManager. It signifies that we should call
+            // SSL.ConfigJSSDefaultCertAuthCallback(...) on this SSL
+            // PRFileDesc pointer, letting us utilize the same certificate
+            // validation logic that SSLSocket had.
+            logger.debug("JSSEngine: applyTrustManagers() - adding Native TrustManager");
+            if (SSL.ConfigJSSDefaultCertAuthCallback(ssl_fd) == SSL.SECFailure) {
+                throw new SSLException("Unable to configure JSSNativeTrustManager on this JSSengine: " + errorText(PR.GetError()));
+            }
+            return;
+        }
+
+        if (as_server) {
+            // We need to manually invoke the async cert auth handler. However,
+            // SSLFDProxy makes this easy for us: our CertAuthHandler derives
+            // from Runnable, so we can reuse it here as well. We can create
+            // it ahead of time though. In this case, checkNeedCertValidation()
+            // is never called.
+            ssl_fd.certAuthHandler = new CertValidationTask(ssl_fd);
+
+            if (SSL.ConfigSyncTrustManagerCertAuthCallback(ssl_fd) == SSL.SECFailure) {
+                throw new SSLException("Unable to configure TrustManager validation on this JSSengine: " + errorText(PR.GetError()));
+            }
+        } else {
+            // Otherwise, we need a hook from NSS into the SSLFDProxy.
+            //
+            // This hook executes all TrustManagers and if any exception
+            // occurs, we'll turn it into the proper response within NSS.
+            if (SSL.ConfigAsyncTrustManagerCertAuthCallback(ssl_fd) == SSL.SECFailure) {
+                throw new SSLException("Unable to configure TrustManager validation on this JSSengine: " + errorText(PR.GetError()));
+            }
+        }
+    }
+
+    public void beginHandshake() throws SSLException {
+        logger.debug("JSSEngine: beginHandshake()");
+
+        // We assume beginHandshake(...) is the entry point for initializing
+        // the buffer. In particular, wrap(...) / unwrap(...) *MUST* call
+        // beginHandshake(...) if ssl_fd == null.
+
+        // ssl_fd == null <-> we've not initialized anything yet.
+
+        // TLS begins with the client sending a CLIENT_HELLO to the server;
+        // this means that the server needs to unwrap first and the client
+        // needs to wrap first; hence unwrap = as_server. However, if we're
+        // trying to renegotiate this changes. See when ssl_fd != null below.
+        boolean unwrap = as_server;
+
+        if (ssl_fd == null) {
+            // Initialize and create ssl_fd. Throws various RuntimeExceptions
+            // when creation and configuration fails.
+            init();
+            assert(ssl_fd != null);
+
+            // Reset the handshake status, using the new socket and
+            // configuration which was just created. This ensures that
+            // we'll attempt to handshake when ForceHandshake is called.
+            if (SSL.ResetHandshake(ssl_fd, as_server) == SSL.SECFailure) {
+                throw new RuntimeException("Unable to begin handshake: " + errorText(PR.GetError()));
+            }
+        } else {
+            // When ssl_fd exists, we need to re-handshake. Usually, the
+            // server initiates the conversation (especially when we want
+            // to upgrade to requiring client auth from not requiring it).
+            //
+            // This means that when we're a (as_server == true), we should
+            // now wrap, rather than unwrap. So, negate unwrap.
+            unwrap = !as_server;
+
+            // TLS v1.3 differs from all previous versions in that it removed
+            // the ability to completely rehandshake. This makes the first
+            // portion more complicated than the latter.
+            if (session.getSSLVersion() == SSLVersion.TLS_1_3) {
+                // We only send the certificate request as a server when we
+                // need client auth. Otherwise, we'll have to issue a rekey
+                // request.
+                boolean send_certificate_request = as_server && need_client_auth;
+                if (send_certificate_request) {
+                    if (SSL.SendCertificateRequest(ssl_fd) == SSL.SECFailure) {
+                        throw new RuntimeException("Unable to issue certificate request on TLSv1.3: " + errorText(PR.GetError()));
+                    }
+                } else {
+                    // Our best guess at what the user wants is to update
+                    // their keys. They don't need client authentication but
+                    // they explicitly called beginHandshake() again.
+                    if (SSL.KeyUpdate(ssl_fd, false) == SSL.SECFailure) {
+                        throw new RuntimeException("Unable to request a new key on TLSv1.3: " + errorText(PR.GetError()));
+                    }
+                }
+            } else {
+                // On older protocol versions, this is easier: just issue a
+                // new handshake request. This is different from
+                // ResetHandshake as for security reasons, the semantics have
+                // to differ.
+                if (SSL.ReHandshake(ssl_fd, true) == SSL.SECFailure) {
+                    throw new RuntimeException("Unable to rehandshake: " + errorText(PR.GetError()));
+                }
+            }
+        }
+
+        // Make sure we reset the handshake completion status in order for the
+        // callback to work correctly.
+        ssl_fd.handshakeComplete = false;
+
+        // This leaves setting internal variables for HandshakeStatus and
+        // the reporting up from SSLEngine.
+        if (unwrap) {
+            handshake_state = SSLEngineResult.HandshakeStatus.NEED_UNWRAP;
+        } else {
+            handshake_state = SSLEngineResult.HandshakeStatus.NEED_WRAP;
+        }
+
+        // We've begun a new handshake; make sure we step it and reset
+        // our unknown state count to zero.
+        step_handshake = true;
+        unknown_state_count = 0;
+    }
+
+    public void closeInbound() {
+        logger.debug("JSSEngine: closeInbound()");
+
+        is_inbound_closed = true;
+    }
+
+    public void closeOutbound() {
+        logger.debug("JSSEngine: closeOutbound()");
+
+        is_outbound_closed = true;
+    }
+
+    private void markClosed() {
+        if (is_inbound_closed) {
+            PR.Shutdown(ssl_fd, PR.SHUTDOWN_RCV);
+        }
+
+        if (is_outbound_closed) {
+            PR.Shutdown(ssl_fd, PR.SHUTDOWN_SEND);
+        }
+    }
+
+    public String getHostname() {
+        return hostname;
+    }
+
+    public Runnable getDelegatedTask() {
+        logger.debug("JSSEngine: getDelegatedTask()");
+
+        checkNeedCertValidation();
+
+        return task;
+    }
+
+    private boolean checkNeedCertValidation() {
+        logger.debug("JSSEngine: checkNeedCertValidation()");
+        if (task != null) {
+            if (!task.finished) {
+                // Already created runnable task; exit with true status to
+                // show it still needs to be run.
+                logger.debug("JSSEngine: checkNeedCertValidation() - task not done");
+                return true;
+            }
+
+            logger.debug("JSSEngine: checkNeedCertValidation() - task done with code " + task.result);
+
+            // Since the task has finished, we now need to inform NSS about
+            // the results of our certificate validation step.
+            if (SSL.AuthCertificateComplete(ssl_fd, task.result) != SSL.SECSuccess) {
+                String msg = "Got unexpected failure finishing cert ";
+                msg += "authentication in NSS. Returned code ";
+                msg += task.result;
+                throw new RuntimeException(msg);
+            }
+
+            // After checking certificates, our best guess will be that we
+            // need to run wrap again. This is because we either need to
+            // inform the caller of an error that occurred, or continue the
+            // handshake. Worst case, we'll call updateHandshakeState() and
+            // it'll correct our mmistake eventually.
+
+            logger.debug("JSSEngine: checkNeedCertValidation() - task done, removing");
+
+            task = null;
+            handshake_state = SSLEngineResult.HandshakeStatus.NEED_WRAP;
+            ssl_fd.needCertValidation = false;
+
+            return false;
+        }
+
+        if (ssl_fd == null) {
+            // If we don't have a SSLFDProxy instance, nothing we can do but
+            // skip checking if the task exists. Return false to show that
+            // we don't yet have a runnable task.
+            logger.debug("JSSEngine: checkNeedCertValidation() - no ssl_fd");
+            return false;
+        }
+
+        if (!ssl_fd.needCertValidation) {
+            // We don't yet need certificate validation. Don't create a
+            // runnable task for now.
+            logger.debug("JSSEngine: checkNeedCertValidation() - no need for cert validation");
+            return false;
+        }
+
+        logger.debug("JSSEngine: checkNeedCertValidation() - creating task");
+
+        // OK, time to create our runnable task.
+        task = new CertValidationTask(ssl_fd);
+
+        // Update our handshake state so we know what to do next.
+        handshake_state = SSLEngineResult.HandshakeStatus.NEED_TASK;
+
+        return true;
+    }
+
+    public SSLEngineResult.HandshakeStatus getHandshakeStatus() {
+        logger.debug("JSSEngine: getHandshakeStatus()");
+
+        // If task is NULL, we need to update the state to check if the
+        // task has been "run". Even if it isn't, it would be good to
+        // update the status here as well. However, we DO NOT want to
+        // call updateHandshakeState() in the event we have a task to
+        // run: we need to run it still!
+        if (checkNeedCertValidation()) {
+            return handshake_state;
+        }
+
+        // Always update the handshake state; this ensures that we catch
+        // looping due to missing data and flip our expected direction.
+        updateHandshakeState();
+
+        return handshake_state;
+    }
+
+    public SecurityStatusResult getStatus() {
+        if (ssl_fd == null) {
+            return null;
+        }
+
+        return SSL.SecurityStatus(ssl_fd);
+    }
+
+    private int computeSize(ByteBuffer[] buffers, int offset, int length) throws IllegalArgumentException {
+        logger.debug("JSSEngine: computeSize()");
+        int result = 0;
+
+        if (buffers == null || buffers.length == 0) {
+            logger.debug("JSSEngine.computeSize(): no buffers - result=" + result);
+            return result;
+        }
+
+        // Semantics of arguments:
+        //
+        // - buffers is where we're reading/writing application data.
+        // - offset is the index of the first buffer we read/write to.
+        // - length is the total number of buffers we read/write to.
+        //
+        // We use a relative index and an absolute index to handle these
+        // constraints.
+        for (int rel_index = 0; rel_index < length; rel_index++) {
+            int index = offset + rel_index;
+            if (index >= buffers.length) {
+                throw new IllegalArgumentException("offset (" + offset + ") or length (" + length + ") exceeds contract based on number of buffers (" + buffers.length + ")");
+            }
+
+            if (rel_index == 0 && buffers[index] == null) {
+                // If our first buffer is null, assume the rest are and skip
+                // everything else. This commonly happens when null is passed
+                // as the src parameter to wrap or when null is passed as the
+                // dst parameter to unwrap.
+                logger.debug("JSSEngine.computeSize(): null first buffer - result=" + result);
+                return result;
+            }
+
+            if (buffers[index] == null) {
+                throw new IllegalArgumentException("Buffer at index " + index + " is null.");
+            }
+
+            result += buffers[index].remaining();
+        }
+
+        logger.debug("JSSEngine.computeSize(): result=" + result);
+
+        return result;
+    }
+
+    private int putData(byte[] data, ByteBuffer[] buffers, int offset, int length) {
+        logger.debug("JSSEngine: putData()");
+        // Handle the rather unreasonable task of moving data into the buffers.
+        // We assume the buffer parameters have already been checked by
+        // computeSize(...); that is, offset/length contracts hold and that
+        // each buffer in the range is non-null.
+        //
+        // We also assume that data.length does not exceed the total number
+        // of bytes the buffers can hold; this is what computeSize(...)'s
+        // return value should ensure. This directly means that the inner
+        // while loop won't exceed the bounds of offset+length.
+
+        int buffer_index = offset;
+        int data_index = 0;
+
+        if (data == null || buffers == null) {
+            return data_index;
+        }
+
+        for (data_index = 0; data_index < data.length; data_index++) {
+            // Ensure we have have a buffer with capacity.
+            while ((buffers[buffer_index] == null || buffers[buffer_index].remaining() <= 0) &&
+                    (buffer_index < offset + length)) {
+                buffer_index += 1;
+            }
+            if (buffer_index >= offset + length) {
+                break;
+            }
+
+            // Compute the size of the put: it is the minimum of the space
+            // remaining in this buffer and the bytes remaining in the data
+            // array.
+            int put_size = buffers[buffer_index].remaining();
+            if (put_size > (data.length - data_index)) {
+                put_size = data.length - data_index;
+            }
+
+            buffers[buffer_index].put(data, data_index, put_size);
+            data_index += put_size;
+        }
+
+        return data_index;
+    }
+
+    private SSLException checkSSLAlerts() {
+        logger.debug("JSSEngine: Checking inbound and outbound SSL Alerts. Have " + ssl_fd.inboundAlerts.size() + " inbound and " + ssl_fd.outboundAlerts.size() + " outbound alerts.");
+
+        // Prefer inbound alerts to outbound alerts.
+        while (ssl_fd.inboundOffset < ssl_fd.inboundAlerts.size()) {
+            SSLAlertEvent event = ssl_fd.inboundAlerts.get(ssl_fd.inboundOffset);
+            ssl_fd.inboundOffset += 1;
+
+            if (event.getLevelEnum() == SSLAlertLevel.WARNING && event.getDescriptionEnum() == SSLAlertDescription.CLOSE_NOTIFY) {
+                logger.debug("Got inbound CLOSE_NOTIFY alert");
+                closeInbound();
+            }
+
+            logger.debug("JSSEngine: Got inbound alert: " + event);
+
+            SSLException exception = event.toException();
+            if (exception != null) {
+                return exception;
+            }
+        }
+
+        while (ssl_fd.outboundOffset < ssl_fd.outboundAlerts.size()) {
+            SSLAlertEvent event = ssl_fd.outboundAlerts.get(ssl_fd.outboundOffset);
+            ssl_fd.outboundOffset += 1;
+
+            if (event.getLevelEnum() == SSLAlertLevel.WARNING && event.getDescriptionEnum() == SSLAlertDescription.CLOSE_NOTIFY) {
+                logger.debug("Sent outbound CLOSE_NOTIFY alert.");
+                closeOutbound();
+            }
+
+            logger.debug("JSSEngine: Got outbound alert: " + event);
+
+            SSLException exception = event.toException();
+            if (exception != null) {
+                return exception;
+            }
+        }
+
+        return null;
+    }
+
+    private void updateHandshakeState() {
+        logger.debug("JSSEngine: updateHandshakeState()");
+
+        // If we've previously seen an exception, we should just return
+        // here; there's already an alert on the wire, so there's no point
+        // in checking for new ones and/or stepping the handshake: it has
+        // already failed.
+        if (seen_exception) {
+            return;
+        }
+
+        // If we're already done, we should check for SSL ALerts.
+        if (!step_handshake && handshake_state == SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING) {
+            logger.debug("JSSEngine.updateHandshakeState() - not handshaking");
+            unknown_state_count = 0;
+
+            ssl_exception = checkSSLAlerts();
+            seen_exception = (ssl_exception != null);
+            return;
+        }
+
+        // If we've previously finished handshaking, then move to
+        // NOT_HANDSHAKING. Now is also a good time to check for any
+        // alerts.
+        if (!step_handshake && handshake_state == SSLEngineResult.HandshakeStatus.FINISHED) {
+            logger.debug("JSSEngine.updateHandshakeState() - FINISHED to NOT_HANDSHAKING");
+            handshake_state = SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING;
+
+            unknown_state_count = 0;
+
+            ssl_exception = checkSSLAlerts();
+            seen_exception = (ssl_exception != null);
+            return;
+        }
+
+        logger.debug("Stepping handshake? step_handshake=" + step_handshake);
+
+        int pre_read_capacity = JByteBuffer.Capacity(read_buf);
+        int pre_write_capacity = JByteBuffer.Capacity(write_buf);
+        boolean need_wrap = handshake_state == SSLEngineResult.HandshakeStatus.NEED_WRAP;
+        boolean need_unwrap = handshake_state == SSLEngineResult.HandshakeStatus.NEED_UNWRAP;
+        boolean was_finished = ssl_fd.handshakeComplete;
+
+        if (!step_handshake) {
+            // Don't bother calling SSL_ForceHandshake in the event of no
+            // capacity.
+            return;
+        }
+
+        if ((need_unwrap && pre_read_capacity == 0) || (need_wrap && pre_write_capacity == 0)) {
+            logger.debug("pre_read_capacity == " + pre_read_capacity + " || pre_write_capacity == " + pre_write_capacity);
+            unknown_state_count += 1;
+            if (unknown_state_count >= 4) {
+                if (handshake_state == SSLEngineResult.HandshakeStatus.NEED_WRAP) {
+                    handshake_state = SSLEngineResult.HandshakeStatus.NEED_UNWRAP;
+                } else {
+                    handshake_state = SSLEngineResult.HandshakeStatus.NEED_WRAP;
+                }
+                unknown_state_count = 1;
+            }
+
+            return;
+        }
+
+        // Since we're not obviously done handshaking, and the last time we
+        // were called, we were still handshaking, step the handshake.
+        logger.debug("JSSEngine.updateHandshakeState() - forcing handshake");
+        if (SSL.ForceHandshake(ssl_fd) == SSL.SECFailure) {
+            int error_value = PR.GetError();
+
+            if (error_value != PRErrors.WOULD_BLOCK_ERROR) {
+                logger.debug("JSSEngine.updateHandshakeState() - FATAL " + getStatus());
+
+                ssl_exception = new SSLHandshakeException("Error duing SSL.ForceHandshake() :: " + errorText(error_value));
+                seen_exception = true;
+
+                handshake_state = SSLEngineResult.HandshakeStatus.NEED_WRAP;
+                return;
+            }
+        }
+
+        if (need_wrap && JByteBuffer.Capacity(write_buf) == 0 && pre_write_capacity > 0) {
+            // When we just wrapped, but we're out of capacity, assume we
+            // need to wrap again to proceed further.
+            unknown_state_count = 0;
+            return;
+        }
+
+        // We use handshakeComplete because it is a reliable indicator of
+        // when the handshake is complete, unlike SecurityStatus. Notably,
+        // handshakeComplete == true only when the FINISHED message has
+        // been confirmed by both parties.
+        if (was_finished && ssl_fd.handshakeComplete && (need_wrap || need_unwrap)) {
+            logger.debug("JSSEngine.updateHandshakeState() - handshakeComplete is " + ssl_fd.handshakeComplete + ", so we've just finished handshaking");
+            step_handshake = false;
+            handshake_state = SSLEngineResult.HandshakeStatus.FINISHED;
+            unknown_state_count = 0;
+
+            // Only update peer certificate chain when we've finished
+            // handshaking.
+            try {
+                PK11Cert[] peer_chain = SSL.PeerCertificateChain(ssl_fd);
+                session.setPeerCertificates(peer_chain);
+            } catch (Exception e) {
+                String msg = "Unable to get peer's certificate chain: ";
+                msg += e.getMessage();
+
+                seen_exception = true;
+                ssl_exception = new SSLException(msg, e);
+            }
+
+            // Also update our session information here.
+            session.refreshData();
+
+            return;
+        }
+
+        unknown_state_count += 1;
+        if (unknown_state_count >= 4) {
+            if (handshake_state == SSLEngineResult.HandshakeStatus.NEED_WRAP) {
+                handshake_state = SSLEngineResult.HandshakeStatus.NEED_UNWRAP;
+            } else {
+                handshake_state = SSLEngineResult.HandshakeStatus.NEED_WRAP;
+            }
+            unknown_state_count = 1;
+        }
+    }
+
+    private boolean isHandshakeFinished() {
+        logger.debug("JSSEngine: isHandshakeFinished()");
+        return (handshake_state == SSLEngineResult.HandshakeStatus.FINISHED ||
+                (ssl_fd != null && handshake_state == SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING));
+    }
+
+    public SSLEngineResult unwrap(ByteBuffer src, ByteBuffer[] dsts, int offset, int length) throws IllegalArgumentException, SSLException {
+        if (ssl_fd == null) {
+            beginHandshake();
+        }
+
+        int available = src.remaining();
+        int capacity = computeSize(dsts, offset, length);
+
+        // Before going much further, check to see if we need to run a
+        // delegated task. So far, the only delegated tasks we have are
+        // for checking TrustManagers.
+        if (checkNeedCertValidation()) {
+            return new SSLEngineResult(SSLEngineResult.Status.OK, handshake_state, 0, 0);
+        }
+
+        logger.debug("Setting read buffer: " + src);
+        JByteBuffer.SetBuffer(read_buf, src);
+        try {
+            return unwrap(available, dsts, offset, length, capacity);
+        } finally {
+            JByteBuffer.ClearBuffer(read_buf);
+        }
+    }
+
+    public SSLEngineResult unwrap(int src_capacity, ByteBuffer[] dsts, int offset, int length, int dst_capacity) throws IllegalArgumentException, SSLException {
+        logger.debug("JSSEngine: unwrap(ssl_fd=" + ssl_fd + ")");
+
+        // In this method, we're taking the network wire contents of src and
+        // passing them as the read side of our buffer. If there's any data
+        // for us to read from the remote peer (via ssl_fd), we place it in
+        // the various dsts.
+        //
+        // However, we also need to detect if the handshake is still ongoing;
+        // if so, we can't send data (from src) until then.
+
+        // Order of operations:
+        //  1. Read data from srcs
+        //  2. Update handshake status
+        //  3. Write data to dsts
+        //
+        // Since srcs is coming from the data, it could affect our ability to
+        // handshake. It could also affect our ability to write data to dsts,
+        // as src could provide new data to decrypt. When no new data from src
+        // is present, we could have residual steps in handshake(), in which
+        // case no data would be written to dsts. Lastly, even if no new data
+        // from srcs, could still have residual data in read_buf, so we should
+        // attempt to read from the ssl_fd.
+
+        // wire_data is the number of bytes from src we've written into
+        // read_buf.
+        int wire_data = 0;
+
+        // Actual amount of data written to the buffer.
+        int app_data = 0;
+
+        // Whether or not the handshake was complete prior to the
+        // updateHandshakeState() call.
+        boolean handshake_already_finished = ssl_fd.handshakeComplete;
+
+        // In the above, we should always try to read and write data. Check to
+        // see if we need to step our handshake process or not.
+        updateHandshakeState();
+
+        byte[] app_buffer = PR.Read(ssl_fd, dst_capacity);
+        int error = PR.GetError();
+        logger.debug("JSSEngine.unwrap() - " + app_buffer + " error=" + errorText(error));
+        if (app_buffer != null) {
+            app_data = putData(app_buffer, dsts, offset, length);
+        } else if (dst_capacity > 0) {
+            // There are two scenarios we need to ignore here:
+            //  1. WOULD_BLOCK_ERRORs are safe, because we're expecting
+            //     not to block. Usually this means we don't have space
+            //     to write any more data.
+            //  2. SOCKET_SHUTDOWN_ERRORs are safe, because if the
+            //     underling cause was fatal, we'd catch it after exiting
+            //     the do-while loop, in checkSSLAlerts().
+            if (error != 0 && error != PRErrors.WOULD_BLOCK_ERROR && error != PRErrors.SOCKET_SHUTDOWN_ERROR) {
+                ssl_exception = new SSLException("Unexpected return from PR.Read(): " + errorText(error));
+                seen_exception = true;
+            }
+        }
+
+        wire_data = JByteBuffer.ClearBuffer(read_buf);
+
+        if (seen_exception == false && ssl_exception == null) {
+            ssl_exception = checkSSLAlerts();
+            seen_exception = (ssl_exception != null);
+        }
+
+        // Before we return, check if an exception occurred and throw it if
+        // one did.
+        if (ssl_exception != null) {
+            logger.info("JSSEngine.unwrap() - Got SSLException: " + ssl_exception);
+            SSLException excpt = ssl_exception;
+            ssl_exception = null;
+            handshake_state = SSLEngineResult.HandshakeStatus.NEED_WRAP;
+            tryCleanup();
+            throw excpt;
+        }
+
+        SSLEngineResult.Status handshake_status = SSLEngineResult.Status.OK;
+
+
+        if (is_inbound_closed) {
+            logger.debug("Socket is currently closed.");
+            handshake_status = SSLEngineResult.Status.CLOSED;
+        } else if (handshake_already_finished && app_data == 0 && src_capacity > 0) {
+            logger.debug("Got underflow condition");
+            handshake_status = SSLEngineResult.Status.BUFFER_UNDERFLOW;
+        }
+
+        // Need a way to introspect the open/closed state of the TLS
+        // connection.
+
+        logger.debug("JSSEngine.unwrap() - Finished");
+        logger.debug(" - Status: " + handshake_status);
+        logger.debug(" - Handshake State: " + handshake_state);
+        logger.debug(" - wire_data: " + wire_data);
+        logger.debug(" - app_data: " + app_data);
+
+        tryCleanup();
+        return new SSLEngineResult(handshake_status, handshake_state, wire_data, app_data);
+    }
+
+    public int writeData(ByteBuffer[] srcs, int offset, int length) {
+        logger.debug("JSSEngine: writeData()");
+        // This is the tough end of reading/writing. There's two potential
+        // places buffering could occur:
+        //
+        //  - Inside the NSS library (unclear if this happens).
+        //  - write_buf
+        //
+        // So when we call PR.Write(ssl_fd, data), it isn't guaranteed that
+        // we can write all of data to ssl_fd (unlike with all our other read
+        // or write operations where we have a clear bound). In the event that
+        // our Write call is truncated, we have to put data back into the
+        // buffer from whence it was read.
+        //
+        // However, we do use Buffer.WriteCapacity(write_buf) as a proxy
+        // metric for how much we can write without having to place data back
+        // in a src buffer.
+        //
+        // When we don't perform an actual NSPR write call, make a dummy
+        // invocation to ensure we always attempt to flush these buffers.
+        int data_length = 0;
+
+        int index = offset;
+        int max_index = offset + length;
+
+        boolean attempted_write = false;
+
+        while (index < max_index) {
+            // If we don't have any remaining bytes in this buffer, skip it.
+            if (srcs[index] == null || srcs[index].remaining() <= 0) {
+                logger.debug("JSSEngine: skipping null buffer at index=" + index);
+                index += 1;
+                continue;
+            }
+            logger.debug("JSSEngine.writeData(): index=" + index + " max_index=" + max_index);
+
+            // We expect (i.e., need to construct a buffer) to write up to
+            // this much. Note that this is non-zero since we're taking the
+            // max here and we guarantee with the previous statement that
+            // srcs[index].remaining() > 0. There's no point in getting more
+            // than BUFFER_SIZE bytes either; so cap at the minimum of the
+            // two sizes.
+            int expected_write = Math.min(srcs[index].remaining(), BUFFER_SIZE);
+
+            // Get data from our current srcs[index] buffer.
+            byte[] app_data = new byte[expected_write];
+            srcs[index].get(app_data);
+
+            // Actual amount written. Since this is a PR.Write call, mark
+            // attempted_write.
+            int this_write = PR.Write(ssl_fd, app_data);
+            attempted_write = true;
+
+            // Reset our buffer's position in event of sub-optimal write.
+            if (this_write < expected_write) {
+                int pos = srcs[index].position();
+
+                // When this_write < 0, we want to reset to the beginning
+                // because we assume we haven't written any data due to an
+                // error before writing.
+                int delta = expected_write - Math.max(0, this_write);
+
+                srcs[index].position(pos - delta);
+            }
+
+            logger.debug("JSSEngine.writeData(): this_write=" + this_write);
+            if (this_write < 0) {
+                int error = PR.GetError();
+                if (error == PRErrors.SOCKET_SHUTDOWN_ERROR) {
+                    logger.debug("NSPR reports outbound socket is shutdown.");
+                    is_outbound_closed = true;
+                } else if (error != PRErrors.WOULD_BLOCK_ERROR) {
+                    throw new RuntimeException("Unable to write to internal ssl_fd: " + errorText(PR.GetError()));
+                }
+
+                break;
+            }
+
+            data_length += this_write;
+
+            if (this_write < expected_write) {
+                // If we didn't get an error but we got less than our expected
+                // write, it is best to exit to give us time to drain the
+                // buffers before attempting another write. We're guaranteed
+                // to be called again because we wrote a non-zero amount here.
+                break;
+            }
+        }
+
+        // When we didn't call PR.Write, invoke a dummy call to PR.Write to
+        // ensure we always attempt to write to push data from NSS's internal
+        // buffers into our network buffers.
+        if (!attempted_write) {
+            PR.Write(ssl_fd, null);
+        }
+
+        logger.debug("JSSEngine.writeData(): data_length=" + data_length);
+
+        return data_length;
+    }
+
+    public SSLEngineResult wrap(ByteBuffer[] srcs, int offset, int length, ByteBuffer dst) throws IllegalArgumentException, SSLException {
+        if (ssl_fd == null) {
+            beginHandshake();
+        }
+
+        if (ssl_fd.handshakeComplete && srcs != null && dst != null) {
+            int available = computeSize(srcs, offset, length);
+            int capacity = dst.remaining();
+
+            if (available > capacity && capacity < BUFFER_SIZE) {
+                logger.error("wrap - BUFFER_OVERFLOW: " + available + " vs " + capacity);
+                return new SSLEngineResult(SSLEngineResult.Status.BUFFER_OVERFLOW, handshake_state, 0, 0);
+            }
+        }
+
+        // Before going much further, check to see if we need to run a
+        // delegated task. So far, the only delegated tasks we have are
+        // for checking TrustManagers.
+        if (checkNeedCertValidation()) {
+            return new SSLEngineResult(SSLEngineResult.Status.OK, handshake_state, 0, 0);
+        }
+
+        logger.debug("Setting write buffer: " + dst);
+
+        JByteBuffer.SetBuffer(write_buf, dst);
+        try {
+            return wrap(srcs, offset, length);
+        } finally {
+            JByteBuffer.ClearBuffer(write_buf);
+        }
+    }
+
+    public SSLEngineResult wrap(ByteBuffer[] srcs, int offset, int length) throws IllegalArgumentException, SSLException {
+        logger.debug("JSSEngine: wrap(ssl_fd=" + ssl_fd + ")");
+        // In this method, we're taking the application data from the various
+        // srcs and writing it to the remote peer (via ssl_fd). If there's any
+        // data for us to send to the remote peer, we place it in dst.
+        //
+        // However, we also need to detect if the handshake is still ongoing;
+        // if so, we can't send data (from src) until then.
+
+        // Order of operations:
+        //  1. Check if either end of the handshake is closed
+        //  2. Step the handshake
+        //  3. Write data from srcs to ssl_fd
+
+        // Actual amount of data read from srcs (and written to ssl_fd). This
+        // is determined by the PR.Write(...) call on ssl_fd.
+        int app_data = 0;
+
+        // wire_data is the number of bytes written to dst. This is bounded
+        // above by two fields: the number of bytes we can read from
+        // write_buf, and the size of dst, if present.
+        int wire_data = 0;
+
+        if (is_inbound_closed) {
+            closeOutbound();
+        }
+
+        // We have to wait until we've gotten buffers in order to mark the
+        // underlying socket as closed. Otherwise, we wouldn't catch the
+        // resulting exception that gets sent on the wire.
+        markClosed();
+
+        // First we try updating the handshake state.
+        updateHandshakeState();
+        if (ssl_exception == null && seen_exception) {
+            if (handshake_state != SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING) {
+                // In the event that:
+                //
+                //      1. We saw an exception in the past
+                //          --> (seen_exception is true),
+                //      2. We've already thrown it from wrap or unwrap,
+                //          --> (ssl_exception is null),
+                //      3. We were previously handshaking
+                //          --> (handshake_state is a handshaking state),
+                //
+                // we need to make sure wrap is called again to ensure the
+                // alert is actually written to the wire. So here we are,
+                // in wrap and the above hold true; we can mark the handshake
+                // status as "FINISHED" (because well, it is over due to the
+                // alert). That leaves the return state to be anything other
+                // than OK to indicate the error.
+                logger.debug("Setting state to FINISHED because of previous exception and in wrap().");
+                handshake_state = SSLEngineResult.HandshakeStatus.FINISHED;
+            }
+        }
+
+        // Try writing data from srcs to the other end of the connection. Note
+        // that we always attempt this, even if the handshake isn't yet marked
+        // as finished. This is because we need the call to PR.Write(...) to
+        // tell if an alert is getting sent.
+        app_data = writeData(srcs, offset, length);
+        logger.debug("JSSEngine.wrap(): wrote " + app_data + " from srcs to buffer.");
+
+        wire_data = JByteBuffer.ClearBuffer(write_buf);
+
+        if (seen_exception == false && ssl_exception == null) {
+            ssl_exception = checkSSLAlerts();
+            seen_exception = (ssl_exception != null);
+        }
+
+        // Before we return, check if an exception occurred and throw it if
+        // one did.
+        if (ssl_exception != null) {
+            logger.info("JSSEngine.wrap() - Got SSLException: " + ssl_exception);
+            SSLException excpt = ssl_exception;
+            ssl_exception = null;
+            cleanup();
+            throw excpt;
+        }
+
+        // Need a way to introspect the open/closed state of the TLS
+        // connection.
+
+        SSLEngineResult.Status handshake_status = SSLEngineResult.Status.OK;
+
+        if (ssl_exception == null && seen_exception) {
+            logger.debug("Seen and processed exception; closing inbound and outbound because this was the last wrap(...)");
+            closeInbound();
+            closeOutbound();
+        }
+
+        if (is_outbound_closed) {
+            logger.debug("Socket is currently closed.");
+            handshake_status = SSLEngineResult.Status.CLOSED;
+        }
+
+        logger.debug("JSSEngine.wrap() - Finished");
+        logger.debug(" - Status: " + handshake_status);
+        logger.debug(" - Handshake State: " + handshake_state);
+        logger.debug(" - wire_data: " + wire_data);
+        logger.debug(" - app_data: " + app_data);
+
+        tryCleanup();
+        return new SSLEngineResult(handshake_status, handshake_state, app_data, wire_data);
+    }
+
+    /**
+     * Calls cleanup only if both inbound and outbound data streams are
+     * closed.
+     *
+     * This prevents accidental cleanup in the case of a partially open
+     * connection.
+     */
+    public void tryCleanup() {
+        logger.debug("JSSEngine: tryCleanup()");
+        if (is_inbound_closed && is_outbound_closed) {
+            // throw new RuntimeException("Probably shouldn't be here!");
+            cleanup();
+        }
+    }
+
+    /**
+     * Performs cleanup of internal data, closing both inbound and outbound
+     * data streams if still open.
+     */
+    public void cleanup() {
+        logger.debug("JSSEngine: cleanup()");
+
+        if (!is_inbound_closed) {
+            logger.debug("JSSEngine: cleanup() - closing opened inbound socket");
+            closeInbound();
+        }
+
+        if (!is_outbound_closed) {
+            logger.debug("JSSEngine: cleanup() - closing opened outbound socket");
+            closeOutbound();
+        }
+
+        // Then clean up the NSS state.
+        cleanupSSLFD();
+    }
+
+    private void cleanupSSLFD() {
+        if (!closed_fd && ssl_fd != null) {
+            try {
+                SSL.RemoveCallbacks(ssl_fd);
+                PR.Close(ssl_fd);
+                ssl_fd.close();
+            } catch (Exception e) {
+                logger.debug("Got exception trying to cleanup SSLFD: " + e.getMessage());
+            } finally {
+                closed_fd = true;
+            }
+        }
+
+        if (read_buf != null) {
+            JByteBuffer.Free(read_buf);
+            read_buf = null;
+        }
+
+        if (write_buf != null) {
+            JByteBuffer.Free(write_buf);
+            write_buf = null;
+        }
+    }
+
+    private class CertValidationTask extends CertAuthHandler {
+        public CertValidationTask(SSLFDProxy fd) {
+            super(fd);
+        }
+
+        public String findAuthType(SSLFDProxy ssl_fd, PK11Cert[] chain) throws Exception {
+            SSLPreliminaryChannelInfo info = SSL.GetPreliminaryChannelInfo(ssl_fd);
+            if (info == null) {
+                String msg = "Expected non-null result from GetPreliminaryChannelInfo!";
+                throw new RuntimeException(msg);
+            }
+
+            if (!info.haveProtocolVersion()) {
+                String msg = "Expected SSLPreliminaryChannelInfo (";
+                msg += info + ") to have protocol information.";
+                throw new RuntimeException(msg);
+            }
+
+            if (!info.haveCipherSuite()) {
+                String msg = "Expected SSLPreliminaryChannelInfo (";
+                msg += info + ") to have cipher suite information.";
+                throw new RuntimeException(msg);
+            }
+
+            SSLVersion version = info.getProtocolVersion();
+            SSLCipher suite = info.getCipherSuite();
+
+            if (version.value() < SSLVersion.TLS_1_3.value()) {
+                // When we're doing a TLSv1.2 or earlier protocol exchange,
+                // we can simply check the cipher suite value for the
+                // authentication type.
+                if (suite.requiresRSACert()) {
+                    // Java expects RSA_EXPORT to be handled properly.
+                    // However, rather than checking the actual bits in
+                    // the RSA certificate, return it purely based on
+                    // cipher suite name. In modern reality, these ciphers
+                    // should _NEVER_ be negotiated!
+                    if (suite.name().contains("RSA_EXPORT")) {
+                        return "RSA_EXPORT";
+                    }
+
+                    return "RSA";
+                } else if (suite.requiresECDSACert()) {
+                    return "ECDSA";
+                } else if (suite.requiresDSSCert()) {
+                    // Notably, DSS is the same as DSA, but the suite names
+                    // all use DSS while the JDK uses DSA.
+                    return "DSA";
+                }
+                // Implicit else: authType == null, causing TrustManager
+                // check to fail.
+            } else {
+                // For TLSv1.3 and any later protocols, we can't rely on
+                // the above requires() checks, because the actual
+                // signature type depends on the type of the certificate
+                // provided. This makes the TrustManager field redundant,
+                // but yet we still have to provide it.
+                if (chain != null && chain.length > 0 && chain[0] != null) {
+                    PK11Cert cert = chain[0];
+                    PublicKey key = cert.getPublicKey();
+                    return key.getAlgorithm();
+                }
+                // Implicit else here and above: authType == null, which
+                // will cause the TrustManager check to fail.
+            }
+
+            return null;
+        }
+
+        public int check(SSLFDProxy fd) {
+            // Needs to be available for assignException() below.
+            PK11Cert[] chain = null;
+
+            try {
+                chain = SSL.PeerCertificateChain(fd);
+                String authType = findAuthType(fd, chain);
+                logger.debug("CertAuthType: " + authType);
+
+                if (chain == null || chain.length == 0) {
+                    // When the chain is NULL, we'd always fail in the
+                    // TrustManager calls, beacuse they expect a non-NULL,
+                    // non-empty chain. However, this is sometimes desired,
+                    // for instance, if we requested the peer to provide a
+                    // certificate chain and they didn't.
+                    if (as_server == true && !need_client_auth) {
+                        // Since we're a server validating the client's
+                        // chain (and they didn't provide one), we should
+                        // ignore it instead of forcing the problem.
+                        logger.debug("No client certificate chain and client cert not needed.");
+                        return 0;
+                    }
+                }
+
+                for (X509TrustManager tm : trust_managers) {
+                    // X509ExtendedTrustManager lets the TM access the
+                    // SSLEngine while validating certificates. Otherwise,
+                    // the X509TrustManager doesn't have access to that
+                    // parameter. Facilitate it if possible.
+                    if (tm instanceof X509ExtendedTrustManager) {
+                        X509ExtendedTrustManager etm = (X509ExtendedTrustManager) tm;
+                        if (as_server) {
+                            etm.checkClientTrusted(chain, authType, JSSEngineOptimizedImpl.this);
+                        } else {
+                            etm.checkServerTrusted(chain, authType, JSSEngineOptimizedImpl.this);
+                        }
+                    } else {
+                        if (as_server) {
+                            tm.checkClientTrusted(chain, authType);
+                        } else {
+                            tm.checkServerTrusted(chain, authType);
+                        }
+                    }
+                }
+            } catch (Exception excpt) {
+                return assignException(excpt, chain);
+            }
+
+            return 0;
+        }
+
+        private int assignException(Exception excpt, PK11Cert[] chain) {
+            int nss_code = Cert.MatchExceptionToNSSError(excpt);
+
+            if (seen_exception) {
+                return nss_code;
+            }
+
+            String msg = "Got exception while trying to validate ";
+            msg += "peer's certificate chain:\n";
+            if (chain == null) {
+                msg += " - (null chain)\n";
+            } else if (chain.length == 0) {
+                msg += " - (0 length chain)\n";
+            } else {
+                for (PK11Cert cert : chain) {
+                    msg += " - " + cert + "\n";
+                }
+            }
+            msg += "with given TrustManagers:\n";
+            if (trust_managers == null) {
+                msg += " - (null TrustManagers)\n";
+            } else if (trust_managers.length == 0) {
+                msg += " - (0 length TrustManagers)\n";
+            } else {
+                for (X509TrustManager tm : trust_managers) {
+                    msg += " - " + tm + "\n";
+                }
+            }
+            msg += "exception message: " + excpt.getMessage();
+
+            seen_exception = true;
+            ssl_exception = new SSLException(msg, excpt);
+            return nss_code;
+        }
+    }
+}
diff --git a/src/main/java/org/mozilla/jss/ssl/javax/JSSSocketChannel.java b/src/main/java/org/mozilla/jss/ssl/javax/JSSSocketChannel.java
index 6342ba71d..f77a04999 100644
--- a/src/main/java/org/mozilla/jss/ssl/javax/JSSSocketChannel.java
+++ b/src/main/java/org/mozilla/jss/ssl/javax/JSSSocketChannel.java
@@ -39,6 +39,8 @@ public class JSSSocketChannel extends SocketChannel {
 
     private boolean handshakeCompleted = false;
 
+    private SSLEngineResult.HandshakeStatus state;
+
     public JSSSocketChannel(JSSSocket sslSocket, SocketChannel parent, Socket parentSocket, ReadableByteChannel readChannel, WritableByteChannel writeChannel, JSSEngine engine) throws IOException {
         super(null);
 
@@ -119,7 +121,7 @@ public boolean finishConnect() throws IOException {
             }
         }
 
-        SSLEngineResult.HandshakeStatus state = engine.getHandshakeStatus();
+        state = engine.getHandshakeStatus();
         if (state == SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING) {
             return true;
         }
@@ -207,8 +209,8 @@ public boolean finishConnect() throws IOException {
      * Compute the total size of a list of buffers from the specified offest
      * and length.
      */
-    private static long computeSize(ByteBuffer[] buffers, int offset, int length) throws IOException {
-        long result = 0;
+    private static int computeSize(ByteBuffer[] buffers, int offset, int length) throws IOException {
+        int result = 0;
 
         if (buffers == null || buffers.length == 0) {
             return result;
@@ -242,6 +244,7 @@ public synchronized long read(ByteBuffer[] dsts, int offset, int length) throws
             return -1;
         }
 
+        long remoteRead = 0;
         long unwrapped = 0;
         long decrypted = 0;
 
diff --git a/src/main/java/org/mozilla/jss/ssl/javax/j_bytebuffer.c b/src/main/java/org/mozilla/jss/ssl/javax/j_bytebuffer.c
new file mode 100644
index 000000000..9439509fb
--- /dev/null
+++ b/src/main/java/org/mozilla/jss/ssl/javax/j_bytebuffer.c
@@ -0,0 +1,229 @@
+#include "j_bytebuffer.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <jni.h>
+#include "jssutil.h"
+
+j_bytebuffer *jbb_alloc(bool writable) {
+    j_bytebuffer *buf = calloc(1, sizeof(j_bytebuffer));
+
+    // Our j_bytebuffer doesn't initially point to any buffers; this means
+    // that we're unable to read or write from this buffer.
+
+    buf->write_allowed = writable;
+
+    return buf;
+}
+
+size_t
+jbb_clear_buffer(j_bytebuffer *buf, JNIEnv *env, jbyteArray backingArray)
+{
+    if (buf == NULL || env == NULL || buf->contents == NULL) {
+        return 0;
+    }
+
+    // Before going to far, save the number of bytes we read/wrote in this
+    // round.
+    size_t ret = buf->position - buf->offset;
+
+    if (!buf->write_allowed) {
+        // We have no need to preserve the data in this buffer because we're
+        // not allowed to write into it. Free our copy of the buffer data
+        // and return.
+        goto done;
+    }
+
+    if (backingArray == NULL) {
+        return 0;
+    }
+
+    // We wish to preserve changes to our underlying byteArray, so specify 0
+    // as the mode parameter.
+    jbyte *data = NULL;
+    jsize length = 0;
+    if (!JSS_RefByteArray(env, backingArray, &data, &length)) {
+        return 0;
+    }
+
+    memcpy(data, buf->contents, length);
+    JSS_DerefByteArray(env, backingArray, data, 0);
+
+done:
+    free(buf->contents);
+    buf->contents = NULL;
+    buf->position = 0;
+    buf->limit = 0;
+    buf->offset = 0;
+
+    return ret;
+}
+
+bool
+jbb_set_buffer(j_bytebuffer *buf, JNIEnv *env, jbyteArray backingArray,
+               size_t offset, size_t limit)
+{
+    if (buf == NULL || env == NULL || backingArray == NULL) {
+        return false;
+    }
+
+    // Take a copy of the underlying data in the byte array, checking the
+    // offset to ensure it is valid. We take a copy (rather than a reference)
+    // here because the reference won't be valid once we exit from this
+    // method. We need our access to the underlying data to persist out of
+    // this method (and its JNI invocation), into another JNI call (likely
+    // going into NSS and NSPR), and back into jbb_clear_buffer().
+    size_t capacity;
+    if (!JSS_FromByteArray(env, backingArray, &buf->contents, &capacity)
+        || offset > capacity) {
+        // We've failed to set the new data. This means RefByteArray
+        // should've thrown an exception. Reset our contents to NULL
+        // so we don't try using anything.
+        buf->contents = NULL;
+        buf->limit = 0;
+        buf->position = 0;
+        buf->offset = 0;
+        return false;
+    }
+
+    // Otherwise, update our remaining fields with their new values.
+    buf->contents = buf->contents;
+    buf->limit = limit;
+    buf->position = offset;
+    buf->offset = offset;
+    return true;
+}
+
+size_t jbb_position(j_bytebuffer *buf) {
+    if (buf == NULL) {
+        return 0;
+    }
+
+    return buf->position;
+}
+
+size_t jbb_capacity(j_bytebuffer *buf) {
+    if (buf == NULL) {
+        return 0;
+    }
+
+    return buf->limit - buf->position;
+}
+
+int jbb_put(j_bytebuffer *buf, uint8_t byte) {
+    /* ret == EOF <=> can't write to the buffer */
+    if (buf == NULL || buf->contents == NULL ||
+        buf->position == buf->limit)
+    {
+        return EOF;
+    }
+
+    buf->contents[buf->position] = byte;
+    buf->position += 1;
+
+    // Semantics of put.
+    return byte;
+}
+
+size_t jbb_write(j_bytebuffer *buf, const uint8_t *input, size_t input_size) {
+    /* ret == 0 <=> can't write to the buffer or input_size == 0 */
+    if (buf == NULL || buf->contents == NULL || input == NULL ||
+        input_size == 0 || buf->position >= buf->limit || !buf->write_allowed)
+    {
+        return 0;
+    }
+
+    // When the input size exceeds that of the remaining space in the
+    // destination buffer, update the write size to reflect the smaller
+    // of the two values.
+    size_t write_size = input_size;
+    size_t remaining_space = buf->limit - buf->position;
+    if (write_size > remaining_space) {
+        write_size = remaining_space;
+    }
+
+    // Copy the data we're writing to this buffer at the specified location,
+    // bounding by the reduced write size.
+    memcpy(
+        buf->contents + buf->position,
+        input,
+        write_size
+    );
+
+    // Update our position so we don't overwrite what we just wrote.
+    buf->position += write_size;
+
+    // Semantics of write.
+    return write_size;
+}
+
+int jbb_get(j_bytebuffer *buf) {
+    /* ret == EOF <=> can't read from the buffer */
+    if (buf == NULL || buf->contents == NULL ||
+        buf->position == buf->limit)
+    {
+        return EOF;
+    }
+
+    uint8_t result = buf->contents[buf->position];
+    buf->position += 1;
+
+    // Semantics of get.
+    return result;
+}
+
+size_t jbb_read(j_bytebuffer *buf, uint8_t *output, size_t output_size) {
+    /* ret == 0 <=> can't read from the buffer or output_size == 0 */
+    if (buf == NULL || buf->contents == NULL || output == NULL ||
+        output_size == 0 || buf->position >= buf->limit || buf->write_allowed)
+    {
+        return 0;
+    }
+
+    // When the output size exceeds that of the remaining space in the
+    // destination buffer, update the read size to reflect the smaller of
+    // the two values.
+    size_t read_size = output_size;
+    size_t remaining_space = buf->limit - buf->position;
+    if (read_size > remaining_space) {
+        read_size = remaining_space;
+    }
+
+    // Copy the data we're reading from this buffer at the specified location
+    // into the output buffer, bounding by the reduced size.
+    memcpy(
+        output,
+        buf->contents + buf->position,
+        read_size
+    );
+
+    // Update our position so we don't re-read what we just read.
+    buf->position += read_size;
+
+    // Semantics of read.
+    return read_size;
+}
+
+void jbb_free(j_bytebuffer *buf, JNIEnv *env) {
+    // Safely handle partial or invalid structures.
+    if (buf == NULL) {
+        return;
+    }
+
+    // Hand the data back to its own. Usually this should be a no-op as the
+    // SSLEngine should make sure to remove the byteBuffers between calls to
+    // wrap/unwrap. However, in order to actually free the data, we need to
+    // set buf->write_allowed = false first.
+    buf->write_allowed = false;
+    jbb_clear_buffer(buf, env, NULL);
+
+    // Overwrite our data so we don't keep references to it.
+    buf->contents = NULL;
+    buf->limit = 0;
+    buf->position = 0;
+    buf->offset = 0;
+
+    free(buf);
+}
diff --git a/src/main/java/org/mozilla/jss/ssl/javax/j_bytebuffer.h b/src/main/java/org/mozilla/jss/ssl/javax/j_bytebuffer.h
new file mode 100644
index 000000000..afe512719
--- /dev/null
+++ b/src/main/java/org/mozilla/jss/ssl/javax/j_bytebuffer.h
@@ -0,0 +1,102 @@
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#include <jni.h>
+
+#pragma once
+
+/*
+ * Opaque structure for using byte buffers from C/JNI. Subject to change at
+ * any time.
+ *
+ * A j_bytebuffer is an interface over a ByteBuffer, for backing IO in
+ * JSSEngineOptimizedImpl. It is only meant to either write or read from
+ * the given buffer; doing both from a single buffer is likely to fail.
+ *
+ * In particular, this structure is useful for invoking a NSPR read/write call
+ * on a pair of ByteBuffers where one is the data to read from (as if it came
+ * off the wire) and the other is the data to write to (as if it were going
+ * to the wire). Before each transaction, this structure is updated with the
+ * current set of buffers. The NSPR call is then performed and the buffers
+ * should be immediately cleared so no future NSPR call uses them.
+ */
+typedef struct {
+    /* Contents of the buffer. Populated via a call to .array() and offset by
+     * .position(). */
+    uint8_t *contents;
+
+    /* Limit is used as a sentinel value; when position == limit,
+     * can't write or read from this buffer. */
+    size_t limit;
+
+    /* Next position to write or read from. */
+    size_t position;
+
+    /* Original position we started at. */
+    size_t offset;
+
+    /* Defines whether or not we're reading or writing to this buffer; if
+     * false, we're not allowed to write and jbb_release_buffer won't attempt
+     * to copy any data back. */
+    bool write_allowed;
+} j_bytebuffer;
+
+/*
+ * Create a new buffer; must be freed with jbb_free.
+ */
+j_bytebuffer *jbb_alloc(bool writable);
+
+/*
+ * Remove the buffers from this j_bytebuffer structure.
+ */
+size_t jbb_clear_buffer(j_bytebuffer *buf, JNIEnv *env,
+                        jbyteArray backingArray);
+
+/*
+ * Update this j_bytebuffer struct with the information from a ByteBuffer.
+ */
+bool jbb_set_buffer(j_bytebuffer *buf, JNIEnv *env, jbyteArray backingArray,
+                    size_t offset, size_t limit);
+
+/* Get the current position of the specified buffer; used for updating the
+ * original ByteBuffer. */
+size_t jbb_position(j_bytebuffer *buf);
+
+/* Get the remaining capacity in this byte buffer. */
+size_t jbb_capacity(j_bytebuffer *buf);
+
+/*
+ * Store a character into the buffer. Returns the character if stored,
+ * else EOF if unable to store the character (because the buffer is full).
+ * When not EOF, can safely be casted to a uint8_t.
+ */
+int jbb_put(j_bytebuffer *buf, uint8_t byte);
+
+/*
+ * Store many characters into the buffer from an array of characters. Returns
+ * the number of characters written into the buffer; max of input_size. This
+ * is zero when the buffer is already full.
+ */
+size_t jbb_write(j_bytebuffer *buf, const uint8_t *input, size_t input_size);
+
+/*
+ * Get the next character from the buffer or EOF if the buffer is empty. If
+ * not EOF, can safely be casted to uint8_t.
+ */
+int jbb_get(j_bytebuffer *buf);
+
+/*
+ * Read several characters from the buffer in the order they were written. The
+ * characters are placed in output and up to output_size characters are read.
+ * Returns the number of characters read; zero if the buffer was empty.
+ */
+size_t jbb_read(j_bytebuffer *buf, uint8_t *output, size_t output_size);
+
+/*
+ * Free a buffer allocated with jbb_alloc. Note that if jbb_set_buffer isn't
+ * called prior to this, we'll copy and release the underlying buffers back
+ * to the backing jbyteArray here. Pass NULL for the env parameter to skip
+ * this.
+ */
+void jbb_free(j_bytebuffer *buf, JNIEnv *env);
diff --git a/src/main/java/org/mozilla/jss/util/java_ids.h b/src/main/java/org/mozilla/jss/util/java_ids.h
index de920dd77..8ef3a0aec 100644
--- a/src/main/java/org/mozilla/jss/util/java_ids.h
+++ b/src/main/java/org/mozilla/jss/util/java_ids.h
@@ -443,6 +443,13 @@ PR_BEGIN_EXTERN_C
  */
 #define SSL_PRELIMINARY_CHANNEL_INFO_CLASS_NAME "org/mozilla/jss/nss/SSLPreliminaryChannelInfo"
 #define SSL_PRELIMINARY_CHANNEL_INFO_CONSTRUCTOR_SIG "(JIIZJZIZZII)V"
+#define SECURITY_STATUS_CONSTRUCTOR_SIG "(I[BII[B[B)V"
+
+/*
+ * ByteBufferProxy
+ */
+#define BYTE_BUFFER_PROXY_CLASS_NAME "org/mozilla/jss/nss/ByteBufferProxy"
+#define BYTE_BUFFER_PROXY_CONSTRUCTOR_SIG "([B)V"
 
 PR_END_EXTERN_C
 
diff --git a/src/test/java/org/mozilla/jss/tests/SSLEngineSimpleDemo.java b/src/test/java/org/mozilla/jss/tests/SSLEngineSimpleDemo.java
new file mode 100644
index 000000000..10ca1c01e
--- /dev/null
+++ b/src/test/java/org/mozilla/jss/tests/SSLEngineSimpleDemo.java
@@ -0,0 +1,424 @@
+/*
+ * Copyright (c) 2004, Oracle and/or its affiliates. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * -Redistribution of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ * -Redistribution in binary form must reproduce the above copyright
+ *  notice, this list of conditions and the following disclaimer in the
+ *  documentation and/or other materials provided with the
+ *  distribution.
+ *
+ * Neither the name of Oracle nor the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind.
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MIDROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN
+ * OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR
+ * FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ *
+ * You acknowledge that this software is not designed, licensed or
+ * intended for use in the design, construction, operation or
+ * maintenance of any nuclear facility.
+ */
+
+/**
+ * A SSLEngine usage example which simplifies the presentation
+ * by removing the I/O and multi-threading concerns.
+ *
+ * The demo creates two SSLEngines, simulating a client and server.
+ * The "transport" layer consists two ByteBuffers:  think of them
+ * as directly connected pipes.
+ *
+ * Note, this is a *very* simple example: real code will be much more
+ * involved.  For example, different threading and I/O models could be
+ * used, transport mechanisms could close unexpectedly, and so on.
+ *
+ * When this application runs, notice that several messages
+ * (wrap/unwrap) pass before any application data is consumed or
+ * produced.  (For more information, please see the SSL/TLS
+ * specifications.)  There may several steps for a successful handshake,
+ * so it's typical to see the following series of operations:
+ *
+ *      client          server          message
+ *      ======          ======          =======
+ *      wrap()          ...             ClientHello
+ *      ...             unwrap()        ClientHello
+ *      ...             wrap()          ServerHello/Certificate
+ *      unwrap()        ...             ServerHello/Certificate
+ *      wrap()          ...             ClientKeyExchange
+ *      wrap()          ...             ChangeCipherSpec
+ *      wrap()          ...             Finished
+ *      ...             unwrap()        ClientKeyExchange
+ *      ...             unwrap()        ChangeCipherSpec
+ *      ...             unwrap()        Finished
+ *      ...             wrap()          ChangeCipherSpec
+ *      ...             wrap()          Finished
+ *      unwrap()        ...             ChangeCipherSpec
+ *      unwrap()        ...             Finished
+ */
+
+package org.mozilla.jss.tests;
+
+import javax.net.ssl.*;
+import javax.net.ssl.SSLEngineResult.*;
+import java.io.*;
+import java.security.*;
+import java.nio.*;
+import java.nio.channels.*;
+import java.net.*;
+
+import org.mozilla.jss.*;
+import org.mozilla.jss.provider.javax.crypto.*;
+import org.mozilla.jss.ssl.*;
+import org.mozilla.jss.ssl.javax.*;
+
+public class SSLEngineSimpleDemo {
+
+    /*
+     * Enables logging of the SSLEngine operations.
+     */
+    private static boolean logging = true;
+
+    /*
+     * Enables the JSSE system debugging system property:
+     *
+     *     -Djavax.net.debug=all
+     *
+     * This gives a lot of low-level information about operations underway,
+     * including specific handshake messages, and might be best examined
+     * after gaining some familiarity with this application.
+     */
+    private static boolean debug = true;
+
+    private SSLContext sslc;
+
+    private SSLEngine clientEngine;     // client Engine
+    private ByteBuffer clientOut;       // write side of clientEngine
+    private ByteBuffer clientIn;        // read side of clientEngine
+
+    private SSLEngine serverEngine;     // server Engine
+    private ByteBuffer serverOut;       // write side of serverEngine
+    private ByteBuffer serverIn;        // read side of serverEngine
+
+    private String alias = "sslserver";
+
+    /*
+     * For data transport, this example uses local ByteBuffers.  This
+     * isn't really useful, but the purpose of this example is to show
+     * SSLEngine concepts, not how to do network transport.
+     */
+    private ByteBuffer cTOs;            // "reliable" transport client->server
+    private ByteBuffer sTOc;            // "reliable" transport server->client
+
+    /*
+     * Main entry point for this demo.
+     */
+    public static void main(String args[]) throws Exception {
+        if (debug) {
+            System.setProperty("javax.net.debug", "all");
+        }
+
+        CryptoManager cm;
+        try {
+            cm = CryptoManager.getInstance();
+        } catch (Exception e) {
+            CryptoManager.initialize(args[0]);
+            cm = CryptoManager.getInstance();
+        }
+        cm.setPasswordCallback(new org.mozilla.jss.tests.FilePasswordCallback(args[1]));
+
+        SSLEngineSimpleDemo demo = new SSLEngineSimpleDemo();
+        if (args.length >= 3) {
+            demo.alias = args[2];
+        }
+        demo.runDemo();
+
+        System.out.println("Demo Completed.");
+    }
+
+    /*
+     * Create an initialized SSLContext to use for this demo.
+     */
+    public SSLEngineSimpleDemo() throws Exception {
+        KeyManagerFactory kmf = KeyManagerFactory.getInstance("NssX509", "Mozilla-JSS");
+
+        SSLContext sslCtx = SSLContext.getInstance("TLS", "Mozilla-JSS");
+        sslCtx.init(kmf.getKeyManagers(), new X509TrustManager[] { new JSSNativeTrustManager() }, null);
+
+        sslc = sslCtx;
+    }
+
+    /*
+     * Run the demo.
+     *
+     * Sit in a tight loop, both engines calling wrap/unwrap regardless
+     * of whether data is available or not.  We do this until both engines
+     * report back they are closed.
+     *
+     * The main loop handles all of the I/O phases of the SSLEngine's
+     * lifetime:
+     *
+     *     initial handshaking
+     *     application data transfer
+     *     engine closing
+     *
+     * One could easily separate these phases into separate
+     * sections of code.
+     */
+    private void runDemo() throws Exception {
+        boolean dataDone = false;
+
+        createSSLEngines();
+        createBuffers();
+
+        SSLEngineResult clientResult;   // results from client's last operation
+        SSLEngineResult serverResult;   // results from server's last operation
+
+        /*
+         * Examining the SSLEngineResults could be much more involved,
+         * and may alter the overall flow of the application.
+         *
+         * For example, if we received a BUFFER_OVERFLOW when trying
+         * to write to the output pipe, we could reallocate a larger
+         * pipe, but instead we wait for the peer to drain it.
+         */
+        int counter = 0;
+        int max_counter = 40;
+
+
+        while (!isEngineClosed(clientEngine) ||
+                !isEngineClosed(serverEngine)) {
+
+            log("================");
+            System.out.println("clientOut=" + clientOut);
+            System.out.println("serverOut=" + serverOut);
+            System.out.println("clientIn=" + clientIn);
+            System.out.println("serverIn=" + serverIn);
+
+
+            clientResult = clientEngine.wrap(clientOut, cTOs);
+            log("client wrap: ", clientResult);
+            runDelegatedTasks(clientResult, clientEngine);
+
+            serverResult = serverEngine.wrap(serverOut, sTOc);
+            log("server wrap: ", serverResult);
+            runDelegatedTasks(serverResult, serverEngine);
+
+            cTOs.flip();
+            sTOc.flip();
+
+            log("----");
+
+            clientResult = clientEngine.unwrap(sTOc, clientIn);
+            log("client unwrap: ", clientResult);
+            runDelegatedTasks(clientResult, clientEngine);
+
+            serverResult = serverEngine.unwrap(cTOs, serverIn);
+            log("server unwrap: ", serverResult);
+            runDelegatedTasks(serverResult, serverEngine);
+
+            cTOs.compact();
+            sTOc.compact();
+
+            /*
+             * After we've transfered all application data between the client
+             * and server, we close the clientEngine's outbound stream.
+             * This generates a close_notify handshake message, which the
+             * server engine receives and responds by closing itself.
+             *
+             * In normal operation, each SSLEngine should call
+             * closeOutbound().  To protect against truncation attacks,
+             * SSLEngine.closeInbound() should be called whenever it has
+             * determined that no more input data will ever be
+             * available (say a closed input stream).
+             */
+            if (!dataDone && (clientOut.limit() == serverIn.position()) &&
+                    (serverOut.limit() == clientIn.position())) {
+
+                /*
+                 * A sanity check to ensure we got what was sent.
+                 */
+                checkTransfer(serverOut, clientIn);
+                checkTransfer(clientOut, serverIn);
+
+                log("\tClosing clientEngine's *OUTBOUND*...");
+                clientEngine.closeOutbound();
+                // serverEngine.closeOutbound();
+                dataDone = true;
+            }
+
+            /*
+            if (clientOut.remaining() == 0) {
+                log("\tClosing clientEngine's *OUTBOUND*...");
+                clientEngine.closeOutbound();
+            }
+
+            if (serverOut.remaining() == 0) {
+                log("\tClosing serverEngine's *OUTBOUND*...");
+                serverEngine.closeOutbound();
+            }*/
+
+            counter += 1;
+            if (counter == max_counter) {
+                throw new RuntimeException("Reasonably expected to be done after " + counter + " steps, but still working...");
+            }
+        }
+
+        checkTransfer(serverOut, clientIn);
+        checkTransfer(clientOut, serverIn);
+    }
+
+    /*
+     * Using the SSLContext created during object creation,
+     * create/configure the SSLEngines we'll use for this demo.
+     */
+    private void createSSLEngines() throws Exception {
+        /*
+         * Configure the serverEngine to act as a server in the SSL/TLS
+         * handshake.  Also, require SSL client authentication.
+         */
+        serverEngine = sslc.createSSLEngine();
+        serverEngine.setUseClientMode(false);
+        serverEngine.setNeedClientAuth(false);
+        serverEngine.setWantClientAuth(false);
+
+        JSSParameters server_params = new JSSParameters();
+        server_params.setAlias(alias);
+        server_params.setProtocols(SSLVersion.TLS_1_2, SSLVersion.TLS_1_2);
+        serverEngine.setSSLParameters(server_params);
+
+        /*
+         * Similar to above, but using client mode instead.
+         */
+        clientEngine = sslc.createSSLEngine("client", 80);
+        clientEngine.setUseClientMode(true);
+
+        JSSParameters client_params = new JSSParameters();
+        client_params.setHostname("localhost");
+        client_params.setProtocols(SSLVersion.TLS_1_2, SSLVersion.TLS_1_2);
+        clientEngine.setSSLParameters(client_params);
+    }
+
+    /*
+     * Create and size the buffers appropriately.
+     */
+    private void createBuffers() {
+
+        /*
+         * We'll assume the buffer sizes are the same
+         * between client and server.
+         */
+        SSLSession session = clientEngine.getSession();
+        int appBufferMax = session.getApplicationBufferSize();
+        int netBufferMax = session.getPacketBufferSize();
+
+        /*
+         * We'll make the input buffers a bit bigger than the max needed
+         * size, so that unwrap()s following a successful data transfer
+         * won't generate BUFFER_OVERFLOWS.
+         *
+         * We'll use a mix of direct and indirect ByteBuffers for
+         * tutorial purposes only.  In reality, only use direct
+         * ByteBuffers when they give a clear performance enhancement.
+         */
+        clientIn = ByteBuffer.allocate(appBufferMax + 50);
+        serverIn = ByteBuffer.allocate(appBufferMax + 50);
+
+        cTOs = ByteBuffer.allocate(netBufferMax);
+        sTOc = ByteBuffer.allocate(netBufferMax);
+
+        clientOut = ByteBuffer.wrap("Hi Server, I'm Client".getBytes());
+        serverOut = ByteBuffer.wrap("Hello Client, I'm Server".getBytes());
+    }
+
+    /*
+     * If the result indicates that we have outstanding tasks to do,
+     * go ahead and run them in this thread.
+     */
+    private static void runDelegatedTasks(SSLEngineResult result,
+            SSLEngine engine) throws Exception {
+
+        if (result.getHandshakeStatus() == HandshakeStatus.NEED_TASK) {
+            Runnable runnable;
+            while ((runnable = engine.getDelegatedTask()) != null) {
+                log("\trunning delegated task...");
+                runnable.run();
+            }
+            HandshakeStatus hsStatus = engine.getHandshakeStatus();
+            if (hsStatus == HandshakeStatus.NEED_TASK) {
+                throw new Exception(
+                    "handshake shouldn't need additional tasks");
+            }
+            log("\tnew HandshakeStatus: " + hsStatus);
+        }
+    }
+
+    private static boolean isEngineClosed(SSLEngine engine) {
+        return (engine.isOutboundDone() && engine.isInboundDone());
+    }
+
+    /*
+     * Simple check to make sure everything came across as expected.
+     */
+    private static void checkTransfer(ByteBuffer a, ByteBuffer b)
+            throws Exception {
+        a.flip();
+        b.flip();
+
+        if (!a.equals(b)) {
+            throw new Exception("Data didn't transfer cleanly");
+        } else {
+            log("\tData transferred cleanly");
+        }
+
+        a.position(a.limit());
+        b.position(b.limit());
+        a.limit(a.capacity());
+        b.limit(b.capacity());
+    }
+
+    /*
+     * Logging code
+     */
+    private static boolean resultOnce = true;
+
+    private static void log(String str, SSLEngineResult result) {
+        if (!logging) {
+            return;
+        }
+        if (resultOnce) {
+            resultOnce = false;
+            System.out.println("The format of the SSLEngineResult is: \n" +
+                "\t\"getStatus() / getHandshakeStatus()\" +\n" +
+                "\t\"bytesConsumed() / bytesProduced()\"\n");
+        }
+        HandshakeStatus hsStatus = result.getHandshakeStatus();
+        log(str +
+            result.getStatus() + "/" + hsStatus + ", " +
+            result.bytesConsumed() + "/" + result.bytesProduced() +
+            " bytes");
+        if (hsStatus == HandshakeStatus.FINISHED) {
+            log("\t...ready for application data");
+        }
+    }
+
+    private static void log(String str) {
+        if (logging) {
+            System.out.println(str);
+        }
+    }
+}
diff --git a/src/test/java/org/mozilla/jss/tests/TestJByteBuffer.java b/src/test/java/org/mozilla/jss/tests/TestJByteBuffer.java
new file mode 100644
index 000000000..2c69389ed
--- /dev/null
+++ b/src/test/java/org/mozilla/jss/tests/TestJByteBuffer.java
@@ -0,0 +1,126 @@
+package org.mozilla.jss.tests;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+
+import org.mozilla.jss.CryptoManager;
+import org.mozilla.jss.nss.*;
+
+public class TestJByteBuffer {
+    public static void TestCapacity() {
+        ByteBuffer buffer = ByteBuffer.allocate(10);
+        assert buffer.position() == 0;
+        assert buffer.limit() == 10;
+
+        ByteBufferProxy proxy = JByteBuffer.Create(false);
+
+        JByteBuffer.SetBuffer(proxy, buffer);
+        assert JByteBuffer.Capacity(proxy) == 10;
+        JByteBuffer.ClearBuffer(proxy);
+
+        buffer.put((byte) '1');
+        assert buffer.position() == 1;
+        assert buffer.limit() == 10;
+
+        JByteBuffer.SetBuffer(proxy, buffer);
+        assert JByteBuffer.Capacity(proxy) == 9;
+        JByteBuffer.ClearBuffer(proxy);
+
+        byte[] array = new byte[20];
+        buffer = ByteBuffer.wrap(array, 5, 10);
+
+        assert buffer.position() == 5;
+        assert buffer.limit() == 15;
+        assert buffer.remaining() == 10;
+
+        JByteBuffer.SetBuffer(proxy, buffer);
+        assert JByteBuffer.Capacity(proxy) == 10;
+        JByteBuffer.ClearBuffer(proxy);
+
+        buffer.put((byte) '1');
+        assert buffer.position() == 6;
+        assert buffer.limit() == 15;
+        assert buffer.remaining() == 9;
+
+        JByteBuffer.SetBuffer(proxy, buffer);
+        assert JByteBuffer.Capacity(proxy) == 9;
+        JByteBuffer.ClearBuffer(proxy);
+    }
+
+    public static void TestWriting() {
+        ByteBuffer buffer = ByteBuffer.allocate(10);
+        assert buffer.position() == 0;
+        assert buffer.limit() == 10;
+
+        ByteBufferProxy read_proxy = JByteBuffer.Create(false);
+        ByteBufferProxy write_proxy = JByteBuffer.Create(true);
+
+        PRFDProxy fd = PR.NewByteBufferPRFD(read_proxy, write_proxy, null);
+
+        JByteBuffer.SetBuffer(write_proxy, buffer);
+        assert JByteBuffer.Capacity(write_proxy) == 10;
+        byte[] data = new byte[1];
+        data[0] = (byte) 1;
+        assert PR.Write(fd, data) == 1;
+        assert JByteBuffer.Capacity(write_proxy) == 9;
+        JByteBuffer.ClearBuffer(write_proxy);
+        assert buffer.position() == 1;
+        buffer.position(0);
+        assert buffer.get() == (byte) 1;
+    }
+
+    public static void TestFlipping() {
+        ByteBuffer buffer = ByteBuffer.allocate(10);
+        assert buffer.position() == 0;
+        assert buffer.limit() == 10;
+
+        ByteBufferProxy read_proxy = JByteBuffer.Create(false);
+        ByteBufferProxy write_proxy = JByteBuffer.Create(true);
+
+        PRFDProxy fd = PR.NewByteBufferPRFD(read_proxy, write_proxy, null);
+
+        JByteBuffer.SetBuffer(write_proxy, buffer);
+        assert JByteBuffer.Capacity(write_proxy) == 10;
+
+        byte[] data = new byte[] {
+            (byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 5,
+            (byte) 6, (byte) 7, (byte) 8, (byte) 9, (byte) 10
+        };
+        assert PR.Write(fd, data) == 10;
+
+        assert JByteBuffer.Capacity(write_proxy) == 0;
+        JByteBuffer.ClearBuffer(write_proxy);
+        assert JByteBuffer.Capacity(write_proxy) == 0;
+
+        buffer.flip();
+
+        assert buffer.position() == 0;
+        assert buffer.limit() == 10;
+        assert buffer.remaining() == 10;
+
+        JByteBuffer.SetBuffer(read_proxy, buffer);
+        assert JByteBuffer.Capacity(read_proxy) == 10;
+
+        byte[] other_data = PR.Read(fd, 10);
+        assert other_data != null;
+        assert other_data.length == data.length;
+        assert Arrays.equals(data, other_data);
+
+        assert JByteBuffer.Capacity(read_proxy) == 0;
+        JByteBuffer.ClearBuffer(read_proxy);
+        assert JByteBuffer.Capacity(read_proxy) == 0;
+    }
+
+    public static void main(String[] args) throws Exception {
+        CryptoManager.getInstance();
+
+        System.out.println("TestCapacity()...");
+        TestCapacity();
+
+        System.out.println("TestWriting()...");
+        TestWriting();
+
+        System.out.println("TestFlipping()...");
+        TestFlipping();
+    }
+}
diff --git a/tools/run_java.sh.in b/tools/run_java.sh.in
new file mode 100755
index 000000000..2c96ceb9d
--- /dev/null
+++ b/tools/run_java.sh.in
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+# This utility gets templated to build/run_java.sh to help with running a
+# single test after building JSS. This gives the caller more flexibility
+# with command line arguments and ensures that the correct build artifacts
+# get used. Unlike run_test.sh however, this utility runs without loading
+# JSS via java.security, allowing it to be used for benchmarking SSLSocket
+# with non-JSS implementations.
+
+export LD_LIBRARY_PATH="${NSS_LIBRARIES}:${CMAKE_BINARY_DIR}:${NSPR_LIBRARIES}"
+export CLASSPATH="${TEST_CLASSPATH}"
+
+if [ "$1" == "--gdb" ]; then
+    shift
+    gdb --args "${Java_JAVA_EXECUTABLE}" -classpath "$CLASSPATH" -ea -Djava.library.path="$LD_LIBRARY_PATH" -Djava.util.logging.config.file="${PROJECT_SOURCE_DIR}/tools/logging.properties" "$@"
+elif [ "$1" == "--valgrind" ]; then
+    shift
+    valgrind --leak-check=full --track-origins=yes --show-leak-kinds=all "${Java_JAVA_EXECUTABLE}" -classpath "${TEST_CLASSPATH}" -ea -Djava.library.path="$LD_LIBRARY_PATH" -Djava.util.logging.config.file="${PROJECT_SOURCE_DIR}/tools/logging.properties" "$@"
+elif [ "$1" == "--perf" ]; then
+    shift
+    perf record -- "${Java_JAVA_EXECUTABLE}" -classpath "${TEST_CLASSPATH}" -ea -Djava.library.path="$LD_LIBRARY_PATH" -Djava.util.logging.config.file="${PROJECT_SOURCE_DIR}/tools/logging.properties" "$@"
+else
+    "${Java_JAVA_EXECUTABLE}" -classpath "$CLASSPATH" -ea -Djava.library.path="$LD_LIBRARY_PATH" -Djava.util.logging.config.file="${PROJECT_SOURCE_DIR}/tools/logging.properties" "$@"
+fi