Implement JwkSerializer for OpenSSL.

net/cert/jwk_serializer_openssl.cc

Index: net/cert/jwk_serializer_openssl.cc
diff --git a/net/cert/jwk_serializer_openssl.cc b/net/cert/jwk_serializer_openssl.cc
index b11e9696d6f30383b33a98ed5efa7fab161eaa52..d4cebb4a4a2d2052267f44d88a7d207fc815baca 100644
--- a/net/cert/jwk_serializer_openssl.cc
+++ b/net/cert/jwk_serializer_openssl.cc
@@ -4,18 +4,106 @@
 
 #include "net/cert/jwk_serializer.h"
 
+#include <openssl/bn.h>
+#include <openssl/ec.h>
+#include <openssl/ec_key.h>
+#include <openssl/evp.h>
+#include <openssl/x509.h>
+
+#include "base/base64.h"
 #include "base/logging.h"
+#include "base/strings/string_util.h"
+#include "base/values.h"
+#include "crypto/openssl_util.h"
+#include "crypto/scoped_openssl_types.h"
 
 namespace net {
 
 namespace JwkSerializer {
 
+namespace {
+
+bool ConvertEcKeyToJwk(EVP_PKEY* pkey,
+                       base::DictionaryValue* public_key_jwk,
+                       const crypto::OpenSSLErrStackTracer& err_tracer) {
+  crypto::ScopedEC_KEY ec_key(EVP_PKEY_get1_EC_KEY(pkey));
+  if (!ec_key)
+    return false;
+  const EC_GROUP* ec_group = EC_KEY_get0_group(ec_key.get());
+  if (!ec_group)
+    return false;
+
+  std::string curve_name;
+  int nid = EC_GROUP_get_curve_name(ec_group);
+  if (nid == NID_X9_62_prime256v1) {
+    curve_name = "P-256";
+  } else if (nid == NID_secp384r1) {
+    curve_name = "P-384";
+  } else if (nid == NID_secp521r1) {
+    curve_name = "P-521";
+  } else {
+    return false;
+  }
+
+  int degree_bytes = (EC_GROUP_get_degree(ec_group) + 7) / 8;
+
+  const EC_POINT* ec_point = EC_KEY_get0_public_key(ec_key.get());
+  if (!ec_point)
+    return false;
+
+  crypto::ScopedBIGNUM x(BN_new());
+  crypto::ScopedBIGNUM y(BN_new());
+  if (!EC_POINT_get_affine_coordinates_GFp(ec_group, ec_point,
+                                           x.get(), y.get(), NULL)) {
+    return false;
+  }
+
+  // The coordinates are encoded with leading zeros included.

[Ryan Sleevi, 2014/07/30 00:18:10]

This is a violation of JWK, FWIW.

Are you matching NSS behaviour?

[davidben, 2014/07/30 00:23:22]

Hrm. Are you sure? This guy says:
http://tools.ietf.org/html/draft-ietf-jose-json-web-algorithms-17#section-5.2...

"""
  The length of this octet string MUST
   be the full size of a coordinate for the curve specified in the "crv"
   parameter.  For example, if the value of "crv" is "P-521", the octet
   string must be 66 octets long.
"""
Yeah, there's a test that goes out of it's way to assert this code does this.
(With an invalid key, but I've fixed it to use a valid key. Had to run openssl
ecparam in a loop until it gave me one that worked. :-) )

[Ryan Sleevi, 2014/07/30 00:36:59]

Right, ok. JWK's gotten sloppy again. The issue with JWK is that all encodings
must use the "minimum number" of octets to encode, but it's splattered about
(see, e.g. 6.1.3.2 of JWA-31, which is the current draft)

That said,
http://tools.ietf.org/html/draft-ietf-jose-json-web-algorithms-31#section-6.2...
is explicit about the x/y having the leading zero, so all good.

+  std::string x_bytes;
+  std::string y_bytes;
+  if (!BN_bn2bin_padded(reinterpret_cast<uint8_t*>(
+          WriteInto(&x_bytes, degree_bytes + 1)), degree_bytes, x.get()) ||
+      !BN_bn2bin_padded(reinterpret_cast<uint8_t*>(
+          WriteInto(&y_bytes, degree_bytes + 1)), degree_bytes, y.get())) {
+    return false;
+  }
+
+  public_key_jwk->SetString("kty", "EC");
+  public_key_jwk->SetString("crv", curve_name);
+
+  std::string x_b64;
+  base::Base64Encode(x_bytes, &x_b64);

[eroman, 2014/11/07 01:04:49]

Note that JWK uses base64url not vanilla base64 encoding (the difference is how
'+' and '/' are output)

[juanlang (chromium.org), 2014/11/07 01:08:18]

Yes, this was logged as bug 364749. I'm sorry I haven't gotten to it.

+  public_key_jwk->SetString("x", x_b64);
+
+  std::string y_b64;
+  base::Base64Encode(y_bytes, &y_b64);
+  public_key_jwk->SetString("y", y_b64);
+
+  return true;
+}
+
+}  // namespace
+
 bool ConvertSpkiFromDerToJwk(
     const base::StringPiece& spki_der,
     base::DictionaryValue* public_key_jwk) {
-  // TODO(juanlang): implement
-  NOTIMPLEMENTED();
-  return false;
+  public_key_jwk->Clear();
+
+  crypto::EnsureOpenSSLInit();
+  crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
+
+  const uint8_t *data = reinterpret_cast<const uint8_t*>(spki_der.data());
+  const uint8_t *ptr = data;
+  crypto::ScopedEVP_PKEY pubkey(d2i_PUBKEY(NULL, &ptr, spki_der.size()));
+  if (!pubkey || ptr != data + spki_der.size())
+    return false;
+
+  if (pubkey->type == EVP_PKEY_EC) {
+    return ConvertEcKeyToJwk(pubkey.get(), public_key_jwk, err_tracer);
+  } else {
+    // TODO(juanlang): other algorithms
+    return false;
+  }
 }
 
 }  // namespace JwkSerializer