Define FIDO U2f Device abstraction

device/u2f/u2f_responses.h

Index: device/u2f/u2f_responses.h
diff --git a/device/u2f/u2f_responses.h b/device/u2f/u2f_responses.h
new file mode 100644
index 0000000000000000000000000000000000000000..52275b075ee363b7f66e1e034b8df171964ca5ab
--- /dev/null
+++ b/device/u2f/u2f_responses.h
@@ -0,0 +1,86 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef DEVICE_U2F_U2F_RESPONSES_H_
+#define DEVICE_U2F_U2F_RESPONSES_H_
+
+#include <vector>
+
+#include "device/u2f/u2f_apdu_response.h"
+
+namespace device {
+
+// Parameter object defining the response to a U2fDevice::Register message. Raw
+// messages parameters are defined by the specification at
+// https://fidoalliance.org/specs/fido-u2f-v1.0-nfc-bt-amendment-20150514/fido-u2f-raw-message-formats.html
+class U2fRegisterResponse
+    : public base::RefCountedThreadSafe<U2fRegisterResponse> {

[Reilly Grant (use Gerrit), 2017/01/27 02:06:30]

I should have mentioned this in my response (har har) to you earlier. These
should be plain structs with public members and be passed by const& or
std::unique_ptr. Reference counting is unnecessary for something that will only
have one owner.

+ public:
+  scoped_refptr<U2fRegisterResponse> Create(
+      U2fApduResponse::Status status,
+      std::vector<uint8_t> user_public_key,

[juanlang (chromium.org), 2017/01/27 18:52:21]

TL;DR: I think returning an opaque string of bytes with the entire response body
might be preferable.

This an interesting design approach, one which I admit I hadn't considered. Does
the webauthn API return each individual element from the response separately? If
it returns an opaque string of bytes like the U2F API does, it would be better
to just return the data as a string of bytes, since it avoids having to parse
the response only in order to convert back to raw bytes.

Even if returns each item individually, I wonder whether it might be better to
return U2F responses as opaque strings of bytes from the "bottom half" all the
same. That'll allow you to avoid having to repackage the bytes yourself if you
wire up a plain-old U2F top half to this bottom half. I think doing so will be a
useful vehicle for testing your bottom half, e.g. if you wire up the CryptoToken
extension to this bottom half.

+      std::vector<uint8_t> key_handle,
+      std::vector<uint8_t> attestation_cert,
+      std::vector<uint8_t> signature);
+
+  U2fApduResponse::Status status() const { return status_; };
+  const std::vector<uint8_t> user_public_key() const {
+    return user_public_key_;
+  };
+  const std::vector<uint8_t> key_handle() const { return key_handle_; };
+  const std::vector<uint8_t> attestation_cert() const {
+    return attestation_cert_;
+  };
+  const std::vector<uint8_t> signature() const { return signature_; };
+
+ private:
+  friend class base::RefCountedThreadSafe<U2fRegisterResponse>;
+
+  U2fRegisterResponse(U2fApduResponse::Status status,
+                      std::vector<uint8_t> user_public_key,
+                      std::vector<uint8_t> key_handle,
+                      std::vector<uint8_t> attestation_cert,
+                      std::vector<uint8_t> signature);
+  ~U2fRegisterResponse();
+
+  U2fApduResponse::Status status_;
+  std::vector<uint8_t> user_public_key_;
+  std::vector<uint8_t> key_handle_;
+  std::vector<uint8_t> attestation_cert_;
+  std::vector<uint8_t> signature_;
+};
+
+// Parameter object defining the response to a U2fDevice::Sign message. Raw
+// messages parameters are defined by the specification at
+// https://fidoalliance.org/specs/fido-u2f-v1.0-nfc-bt-amendment-20150514/fido-u2f-raw-message-formats.html
+class U2fSignResponse : public base::RefCountedThreadSafe<U2fSignResponse> {
+ public:
+  scoped_refptr<U2fSignResponse> Create(U2fApduResponse::Status status,
+                                        uint8_t presence,

[juanlang (chromium.org), 2017/01/27 18:52:21]

Same as above.

If you accept my suggestion, you could use the same response class for all APDU
methods.

+                                        uint32_t counter,
+                                        std::vector<uint8_t> signature);
+
+  U2fApduResponse::Status status() const { return status_; };
+  uint8_t presence() { return presence_; }
+  uint32_t counter() { return counter_; }
+  const std::vector<uint8_t> signature() const { return signature_; };
+
+ private:
+  friend class base::RefCountedThreadSafe<U2fSignResponse>;
+
+  U2fSignResponse(U2fApduResponse::Status status,
+                  uint8_t presence,
+                  uint32_t counter,
+                  std::vector<uint8_t> signature);
+  ~U2fSignResponse();
+
+  U2fApduResponse::Status status_;
+  uint8_t presence_;
+  uint32_t counter_;
+  std::vector<uint8_t> signature_;
+};
+
+}  // namespace device
+
+#endif  // DEVICE_U2F_U2F_RESPONSES_H_