Refactor: Expose JwkReader/JwkWriter helper classes.

content/child/webcrypto/jwk.h

 // Copyright 2014 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 CONTENT_CHILD_WEBCRYPTO_JWK_H_
 #define CONTENT_CHILD_WEBCRYPTO_JWK_H_
 
 #include <stdint.h>
 #include <vector>
 
 #include "base/strings/string_piece.h"
 #include "base/values.h"
 #include "content/common/content_export.h"
-#include "third_party/WebKit/public/platform/WebArrayBuffer.h"
 #include "third_party/WebKit/public/platform/WebCrypto.h"
-#include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 
 namespace content {
 
 namespace webcrypto {
 
 class CryptoData;
 class Status;
 
+// Helper class for parsing a JWK from JSON.
+//
+// Init() must be called (and succeed) before it is valid to call any other
+// method.
+class JwkReader {
+ public:
+  JwkReader();
+  ~JwkReader();
+
+  // Initializes a JWK reader by parsing the JSON |bytes|. To succeed the JWK
+  // must have kty of xpected_kty, have an ext compatible with
+  // |expected_extractable| and have usages compatible with expected_usages.
+  Status Init(const CryptoData& bytes,
+              bool expected_extractable,
+              blink::WebCryptoKeyUsageMask expected_usages,
+              const std::string& expected_kty);
+
+  // Returns true if the key |key| is present.
+  bool HasKey(const std::string& key) const;
+
+  // Extracts the required string property with key |key| and saves
+  // the result to |*result|. If the property does not exist or is not a string,
+  // returns an error.
+  Status GetString(const std::string& key, std::string* result) const;
+
+  // Extracts the optional string property with key |key| and saves
+  // the result to |*result| if it was found. If the property exists and is not
+  // a string, returns an error. Otherwise returns success, and sets
+  // |*property_exists| if it was found.
+  Status GetOptionalString(const std::string& key,
+                           std::string* result,
+                           bool* property_exists) const;
+
+  // Extracts the optional array property with key |key| and saves
+  // the result to |*result| if it was found. If the property exists and is not
+  // an array, returns an error. Otherwise returns success, and sets
+  // |*property_exists| if it was found. Note that |*result| is owned by |dict|.
+  Status GetOptionalList(const std::string& key,
+                         base::ListValue** result,
+                         bool* property_exists) const;
+
+  // Extracts the required string property with key |key| and saves
+  // the base64url-decoded bytes to |*result|. If the property does not exist or
+  // is not a string, or could not be base64url-decoded, returns an error.
+  Status GetBytes(const std::string& key, std::string* result) const;
+
+  // Extracts the required base64url property, which is interpreted as being a
+  // big-endian unsigned integer.
+  //
+  // Sequences that contain leading zeros will be rejected.
+  Status GetBigInteger(const std::string& key, std::string* result) const;
+
+  // Extracts the optional boolean property with key |key| and
+  // saves the result to |*result| if it was found. If the property exists and
+  // is not a boolean, returns an error. Otherwise returns success, and sets
+  // |*property_exists| if it was found.
+  Status GetOptionalBool(const std::string& key,
+                         bool* result,
+                         bool* property_exists) const;
+
+  // Checks if the |alg| property matches |expected_algorithm|.
+  Status VerifyAlg(const std::string& expected_algorithm) const;
+
+ private:
+  scoped_ptr<base::DictionaryValue> dict_;
+};
+
+// Helper class for building the JSON for a JWK.
+class JwkWriter {
+ public:
+  // Initializes a writer, and sets the standard JWK properties as indicated.
+  JwkWriter(const std::string& algorithm,
+            bool extractable,
+            blink::WebCryptoKeyUsageMask usages,
+            const std::string& kty);
+
+  // Sets a string parameter |value|.
+  void SetString(const std::string& key, const std::string& value);
+
+  // Sets a bytes parameter |value|, by base64 url-safe encoding it.
+  void SetBytes(const std::string& key, const CryptoData& value);
+
+  // Flattens the JWK to JSON (utf-8 encoded if necessary, however in practice
+  // it will be ASCII).
+  void ToJson(std::vector<uint8_t>* utf8_bytes) const;
+
+ private:
+  base::DictionaryValue dict_;
+};
+
 // Writes a JWK-formatted symmetric key to |jwk_key_data|.
 //  * raw_key_data: The actual key data
 //  * algorithm: The JWK algorithm name (i.e. "alg")
 //  * extractable: The JWK extractability (i.e. "ext")
 //  * usages: The JWK usages (i.e. "key_ops")
 void WriteSecretKeyJwk(const CryptoData& raw_key_data,
                        const std::string& algorithm,
                        bool extractable,
                        blink::WebCryptoKeyUsageMask usages,
                        std::vector<uint8_t>* jwk_key_data);
@@ skipping 96 matching lines @@
 // Base64DecodeUrlSafe() above.
 CONTENT_EXPORT std::string Base64EncodeUrlSafe(const base::StringPiece& input);
 CONTENT_EXPORT std::string Base64EncodeUrlSafe(
     const std::vector<uint8_t>& input);
 
 }  // namespace webcrypto
 
 }  // namespace content
 
 #endif  // CONTENT_CHILD_WEBCRYPTO_JWK_H_