Teach the GCM Driver how to decrypt incoming messages.

components/gcm_driver/crypto/gcm_encryption_provider.h

 // Copyright 2015 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 COMPONENTS_GCM_DRIVER_CRYPTO_GCM_ENCRYPTION_PROVIDER_H_
 #define COMPONENTS_GCM_DRIVER_CRYPTO_GCM_ENCRYPTION_PROVIDER_H_
 
 #include <stdint.h>
 #include <string>
 
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 
 namespace base {
 class FilePath;
 class SequencedTaskRunner;
 }
 
 namespace gcm {
 
+struct EncryptionHeaderValue;
+struct EncryptionKeyHeaderValue;
 class GCMKeyStore;
+struct IncomingMessage;
 class KeyPair;
 
 // Provider that enables the GCM Driver to deal with encryption key management
 // and decryption of incoming messages.
 class GCMEncryptionProvider {
  public:
   // Callback to be invoked when the public encryption key is available.
   using PublicKeyCallback = base::Callback<void(const std::string&)>;
 
+  // Callback to be invoked when a message may have been decrypted.
+  using MessageCallback =
+      base::Callback<void(const IncomingMessage&, bool decryption_successful)>;
+
   GCMEncryptionProvider();
   ~GCMEncryptionProvider();
 
   // Initializes the encryption provider with the |store_path| and the
   // |blocking_task_runner|. Done separately from the constructor in order to
   // avoid needing a blocking task runner for anything using GCMDriver.
   void Init(
       const base::FilePath& store_path,
       const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner);
 
   // Retrieves the public encryption key belonging to |app_id|. If no keys have
   // been associated with |app_id| yet, they will be created.
   void GetPublicKey(const std::string& app_id,
                     const PublicKeyCallback& callback);
 
+  // Determines whether |message| contains encrypted content.
+  bool IsEncryptedMessage(const IncomingMessage& message) const;
+
+  // Decrypts |message| and stores the result in |decrypted_message|. The return
+  // value indicates whether the message could be decrypted successfully.
+  void DecryptMessage(const std::string& app_id,
+                      const IncomingMessage& message,
+                      const MessageCallback& callback);
+
  private:
   void DidGetPublicKey(const std::string& app_id,
                        const PublicKeyCallback& callback,
                        const KeyPair& pair);
 
   void DidCreatePublicKey(const PublicKeyCallback& callback,
                           const KeyPair& pair);
 
+  void DecryptMessageWithKey(
+      const IncomingMessage& message,
+      const MessageCallback& callback,
+      const EncryptionHeaderValue& encryption_header,
+      const EncryptionKeyHeaderValue& encryption_key_header,
+      const std::string& ciphertext,
+      const KeyPair& pair);
+
   scoped_refptr<GCMKeyStore> key_store_;
 
   base::WeakPtrFactory<GCMEncryptionProvider> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GCMEncryptionProvider);
 };
 
 }  // namespace gcm
 
 #endif  // COMPONENTS_GCM_DRIVER_CRYPTO_GCM_ENCRYPTION_PROVIDER_H_