1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
// 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_CRYPTAUTH_CRYPTAUTH_ENROLLMENT_MANAGER_H_
#define COMPONENTS_CRYPTAUTH_CRYPTAUTH_ENROLLMENT_MANAGER_H_
#include <memory>
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/time/time.h"
#include "components/cryptauth/cryptauth_gcm_manager.h"
#include "components/cryptauth/proto/cryptauth_api.pb.h"
#include "components/cryptauth/sync_scheduler.h"
class PrefRegistrySimple;
class PrefService;
namespace base {
class Clock;
class Time;
}
namespace cryptauth {
class CryptAuthEnroller;
class CryptAuthEnrollerFactory;
class SecureMessageDelegate;
// This class manages the device's enrollment with CryptAuth, periodically
// re-enrolling to keep the state on the server fresh. If an enrollment fails,
// the manager will schedule the next enrollment more aggressively to recover
// from the failure.
class CryptAuthEnrollmentManager : public SyncScheduler::Delegate,
public CryptAuthGCMManager::Observer {
public:
class Observer {
public:
// Called when an enrollment attempt is started.
virtual void OnEnrollmentStarted() = 0;
// Called when an enrollment attempt finishes with the |success| of the
// attempt.
virtual void OnEnrollmentFinished(bool success) = 0;
virtual ~Observer() {}
};
// Creates the manager:
// |clock|: Used to determine the time between sync attempts.
// |enroller_factory|: Creates CryptAuthEnroller instances to perform each
// enrollment attempt.
// |secure_message_delegate|: Used to generate the user's keypair if it does
// not exist.
// |device_info|: Contains information about the local device that will be
// uploaded to CryptAuth with each enrollment request.
// |gcm_manager|: Used to perform GCM registrations and also notifies when GCM
// push messages trigger re-enrollments.
// Not owned and must outlive this instance.
// |pref_service|: Contains preferences across browser restarts, and should
// have been registered through RegisterPrefs().
CryptAuthEnrollmentManager(
std::unique_ptr<base::Clock> clock,
std::unique_ptr<CryptAuthEnrollerFactory> enroller_factory,
std::unique_ptr<SecureMessageDelegate> secure_message_delegate,
const GcmDeviceInfo& device_info,
CryptAuthGCMManager* gcm_manager,
PrefService* pref_service);
~CryptAuthEnrollmentManager() override;
// Registers the prefs used by this class to the given |pref_service|.
static void RegisterPrefs(PrefRegistrySimple* registry);
// Begins scheduling periodic enrollment attempts.
void Start();
// Adds an observer.
void AddObserver(Observer* observer);
// Removes an observer.
void RemoveObserver(Observer* observer);
// Skips the waiting period and forces an enrollment immediately. If an
// enrollment is already in progress, this function does nothing.
// |invocation_reason| specifies the reason that the enrollment was triggered,
// which is upload to the server.
void ForceEnrollmentNow(InvocationReason invocation_reason);
// Returns true if a successful enrollment has been recorded and this
// enrollment has not expired.
bool IsEnrollmentValid() const;
// Returns the timestamp of the last successful enrollment. If no enrollment
// has ever been made, then a null base::Time object will be returned.
base::Time GetLastEnrollmentTime() const;
// Returns the time to the next enrollment attempt.
base::TimeDelta GetTimeToNextAttempt() const;
// Returns true if an enrollment attempt is currently in progress.
bool IsEnrollmentInProgress() const;
// Returns true if the last enrollment failed and the manager is now
// scheduling enrollments more aggressively to recover. If no enrollment has
// ever been recorded, then this function will also return true.
bool IsRecoveringFromFailure() const;
// Returns the keypair used to enroll with CryptAuth. If no enrollment has
// been completed, then an empty string will be returned.
// Note: These keys are really serialized protocol buffer messages, and should
// only be used by passing to SecureMessageDelegate.
virtual std::string GetUserPublicKey() const;
virtual std::string GetUserPrivateKey() const;
protected:
// Creates a new SyncScheduler instance. Exposed for testing.
virtual std::unique_ptr<SyncScheduler> CreateSyncScheduler();
private:
// CryptAuthGCMManager::Observer:
void OnGCMRegistrationResult(bool success) override;
void OnReenrollMessage() override;
// Callback when a new keypair is generated.
void OnKeyPairGenerated(const std::string& public_key,
const std::string& private_key);
// SyncScheduler::Delegate:
void OnSyncRequested(
std::unique_ptr<SyncScheduler::SyncRequest> sync_request) override;
// Starts a CryptAuth enrollment attempt, generating a new keypair if one is
// not already stored in the user prefs.
void DoCryptAuthEnrollment();
// Starts a CryptAuth enrollment attempt, after a key-pair is stored in the
// user prefs.
void DoCryptAuthEnrollmentWithKeys();
// Callback when |cryptauth_enroller_| completes.
void OnEnrollmentFinished(bool success);
// Used to determine the time.
std::unique_ptr<base::Clock> clock_;
// Creates CryptAuthEnroller instances for each enrollment attempt.
std::unique_ptr<CryptAuthEnrollerFactory> enroller_factory_;
// The SecureMessageDelegate used to generate the user's keypair if it does
// not already exist.
std::unique_ptr<SecureMessageDelegate> secure_message_delegate_;
// The local device information to upload to CryptAuth.
const GcmDeviceInfo device_info_;
// Used to perform GCM registrations and also notifies when GCM push messages
// trigger re-enrollments. Not owned and must outlive this instance.
CryptAuthGCMManager* gcm_manager_;
// Contains perferences that outlive the lifetime of this object and across
// process restarts.
// Not owned and must outlive this instance.
PrefService* pref_service_;
// Schedules the time between enrollment attempts.
std::unique_ptr<SyncScheduler> scheduler_;
// Contains the SyncRequest that |scheduler_| requests when an enrollment
// attempt is made.
std::unique_ptr<SyncScheduler::SyncRequest> sync_request_;
// The CryptAuthEnroller instance for the current enrollment attempt. A new
// instance will be created for each individual attempt.
std::unique_ptr<CryptAuthEnroller> cryptauth_enroller_;
// List of observers.
base::ObserverList<Observer> observers_;
base::WeakPtrFactory<CryptAuthEnrollmentManager> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(CryptAuthEnrollmentManager);
};
} // namespace cryptauth
#endif // COMPONENTS_CRYPTAUTH_CRYPTAUTH_ENROLLMENT_MANAGER_H_
|
