diff --git a/src/ssl/ssl_key_share.cc b/src/ssl/ssl_key_share.cc
new file mode 100644
index 0000000..eb61535
--- /dev/null
+++ b/src/ssl/ssl_key_share.cc
@@ -0,0 +1,245 @@
+/* Copyright (c) 2015, Google Inc.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+
+#include <openssl/ssl.h>
+
+#include <assert.h>
+#include <string.h>
+
+#include <openssl/bn.h>
+#include <openssl/bytestring.h>
+#include <openssl/curve25519.h>
+#include <openssl/ec.h>
+#include <openssl/err.h>
+#include <openssl/mem.h>
+#include <openssl/nid.h>
+
+#include "internal.h"
+#include "../crypto/internal.h"
+
+
+namespace bssl {
+
+namespace {
+
+class ECKeyShare : public SSLKeyShare {
+ public:
+  ECKeyShare(int nid, uint16_t group_id) : nid_(nid), group_id_(group_id) {}
+  ~ECKeyShare() override {}
+
+  uint16_t GroupID() const override { return group_id_; }
+
+  bool Offer(CBB *out) override {
+    assert(!private_key_);
+    /* Set up a shared |BN_CTX| for all operations. */
+    UniquePtr<BN_CTX> bn_ctx(BN_CTX_new());
+    if (!bn_ctx) {
+      return false;
+    }
+    BN_CTXScope scope(bn_ctx.get());
+
+    /* Generate a private key. */
+    UniquePtr<EC_GROUP> group(EC_GROUP_new_by_curve_name(nid_));
+    private_key_.reset(BN_new());
+    if (!group || !private_key_ ||
+        !BN_rand_range_ex(private_key_.get(), 1,
+                          EC_GROUP_get0_order(group.get()))) {
+      return false;
+    }
+
+    /* Compute the corresponding public key and serialize it. */
+    UniquePtr<EC_POINT> public_key(EC_POINT_new(group.get()));
+    if (!public_key ||
+        !EC_POINT_mul(group.get(), public_key.get(), private_key_.get(), NULL,
+                      NULL, bn_ctx.get()) ||
+        !EC_POINT_point2cbb(out, group.get(), public_key.get(),
+                            POINT_CONVERSION_UNCOMPRESSED, bn_ctx.get())) {
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Finish(uint8_t **out_secret, size_t *out_secret_len, uint8_t *out_alert,
+              const uint8_t *peer_key, size_t peer_key_len) override {
+    assert(private_key_);
+    *out_alert = SSL_AD_INTERNAL_ERROR;
+
+    /* Set up a shared |BN_CTX| for all operations. */
+    UniquePtr<BN_CTX> bn_ctx(BN_CTX_new());
+    if (!bn_ctx) {
+      return false;
+    }
+    BN_CTXScope scope(bn_ctx.get());
+
+    UniquePtr<EC_GROUP> group(EC_GROUP_new_by_curve_name(nid_));
+    if (!group) {
+      return false;
+    }
+
+    UniquePtr<EC_POINT> peer_point(EC_POINT_new(group.get()));
+    UniquePtr<EC_POINT> result(EC_POINT_new(group.get()));
+    BIGNUM *x = BN_CTX_get(bn_ctx.get());
+    if (!peer_point || !result || !x) {
+      return false;
+    }
+
+    if (!EC_POINT_oct2point(group.get(), peer_point.get(), peer_key,
+                            peer_key_len, bn_ctx.get())) {
+      *out_alert = SSL_AD_DECODE_ERROR;
+      return false;
+    }
+
+    /* Compute the x-coordinate of |peer_key| * |private_key_|. */
+    if (!EC_POINT_mul(group.get(), result.get(), NULL, peer_point.get(),
+                      private_key_.get(), bn_ctx.get()) ||
+        !EC_POINT_get_affine_coordinates_GFp(group.get(), result.get(), x, NULL,
+                                             bn_ctx.get())) {
+      return false;
+    }
+
+    /* Encode the x-coordinate left-padded with zeros. */
+    size_t secret_len = (EC_GROUP_get_degree(group.get()) + 7) / 8;
+    UniquePtr<uint8_t> secret((uint8_t *)OPENSSL_malloc(secret_len));
+    if (!secret || !BN_bn2bin_padded(secret.get(), secret_len, x)) {
+      return false;
+    }
+
+    *out_secret = secret.release();
+    *out_secret_len = secret_len;
+    return true;
+  }
+
+ private:
+  UniquePtr<BIGNUM> private_key_;
+  int nid_;
+  uint16_t group_id_;
+};
+
+class X25519KeyShare : public SSLKeyShare {
+ public:
+  X25519KeyShare() {}
+  ~X25519KeyShare() override {
+    OPENSSL_cleanse(private_key_, sizeof(private_key_));
+  }
+
+  uint16_t GroupID() const override { return SSL_CURVE_X25519; }
+
+  bool Offer(CBB *out) override {
+    uint8_t public_key[32];
+    X25519_keypair(public_key, private_key_);
+    return !!CBB_add_bytes(out, public_key, sizeof(public_key));
+  }
+
+  bool Finish(uint8_t **out_secret, size_t *out_secret_len, uint8_t *out_alert,
+              const uint8_t *peer_key, size_t peer_key_len) override {
+    *out_alert = SSL_AD_INTERNAL_ERROR;
+
+    UniquePtr<uint8_t> secret((uint8_t *)OPENSSL_malloc(32));
+    if (!secret) {
+      OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
+      return false;
+    }
+
+    if (peer_key_len != 32 || !X25519(secret.get(), private_key_, peer_key)) {
+      *out_alert = SSL_AD_DECODE_ERROR;
+      OPENSSL_PUT_ERROR(SSL, SSL_R_BAD_ECPOINT);
+      return false;
+    }
+
+    *out_secret = secret.release();
+    *out_secret_len = 32;
+    return true;
+  }
+
+ private:
+  uint8_t private_key_[32];
+};
+
+const struct {
+  int nid;
+  uint16_t group_id;
+  const char name[8];
+} kNamedGroups[] = {
+    {NID_secp224r1, SSL_CURVE_SECP224R1, "P-224"},
+    {NID_X9_62_prime256v1, SSL_CURVE_SECP256R1, "P-256"},
+    {NID_secp384r1, SSL_CURVE_SECP384R1, "P-384"},
+    {NID_secp521r1, SSL_CURVE_SECP521R1, "P-521"},
+    {NID_X25519, SSL_CURVE_X25519, "X25519"},
+};
+
+}  // namespace
+
+UniquePtr<SSLKeyShare> SSLKeyShare::Create(uint16_t group_id) {
+  switch (group_id) {
+    case SSL_CURVE_SECP224R1:
+      return UniquePtr<SSLKeyShare>(
+          New<ECKeyShare>(NID_secp224r1, SSL_CURVE_SECP224R1));
+    case SSL_CURVE_SECP256R1:
+      return UniquePtr<SSLKeyShare>(
+          New<ECKeyShare>(NID_X9_62_prime256v1, SSL_CURVE_SECP256R1));
+    case SSL_CURVE_SECP384R1:
+      return UniquePtr<SSLKeyShare>(
+          New<ECKeyShare>(NID_secp384r1, SSL_CURVE_SECP384R1));
+    case SSL_CURVE_SECP521R1:
+      return UniquePtr<SSLKeyShare>(
+          New<ECKeyShare>(NID_secp521r1, SSL_CURVE_SECP521R1));
+    case SSL_CURVE_X25519:
+      return UniquePtr<SSLKeyShare>(New<X25519KeyShare>());
+    default:
+      return nullptr;
+  }
+}
+
+bool SSLKeyShare::Accept(CBB *out_public_key, uint8_t **out_secret,
+                         size_t *out_secret_len, uint8_t *out_alert,
+                         const uint8_t *peer_key, size_t peer_key_len) {
+  *out_alert = SSL_AD_INTERNAL_ERROR;
+  return Offer(out_public_key) &&
+         Finish(out_secret, out_secret_len, out_alert, peer_key, peer_key_len);
+}
+
+int ssl_nid_to_group_id(uint16_t *out_group_id, int nid) {
+  for (const auto &group : kNamedGroups) {
+    if (group.nid == nid) {
+      *out_group_id = group.group_id;
+      return 1;
+    }
+  }
+  return 0;
+}
+
+int ssl_name_to_group_id(uint16_t *out_group_id, const char *name, size_t len) {
+  for (const auto &group : kNamedGroups) {
+    if (len == strlen(group.name) &&
+        !strncmp(group.name, name, len)) {
+      *out_group_id = group.group_id;
+      return 1;
+    }
+  }
+  return 0;
+}
+
+}  // namespace bssl
+
+using namespace bssl;
+
+const char* SSL_get_curve_name(uint16_t group_id) {
+  for (const auto &group : kNamedGroups) {
+    if (group.group_id == group_id) {
+      return group.name;
+    }
+  }
+  return nullptr;
+}