some changes in handling of backup/restore process
[accounts-sso:vitalyrepins-signon.git] / src / signond / credentialsaccessmanager.h
1 /* -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3  * This file is part of signon
4  *
5  * Copyright (C) 2009-2010 Nokia Corporation.
6  *
7  * Contact: Aurel Popirtac <mailto:ext-Aurel.Popirtac@nokia.com>
8  * Contact: Alberto Mardegan <alberto.mardegan@nokia.com>
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public License
12  * version 2.1 as published by the Free Software Foundation.
13  *
14  * This library is distributed in the hope that it will be useful, but
15  * WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
22  * 02110-1301 USA
23  */
24
25 /*!
26   @file credentialsaccessmanager.h
27   Definition of the CredentialsAccessManager object.
28   @ingroup Accounts_and_SSO_Framework
29  */
30
31 #ifndef CREDENTIALS_ACCESS_MANAGER_H
32 #define CREDENTIALS_ACCESS_MANAGER_H
33
34 #include "credentialsdb.h"
35 #include "signonui_interface.h"
36
37 #include <QObject>
38 #include <QPointer>
39 #include <QFlags>
40
41 #include "SignOn/AbstractKeyAuthorizer"
42 #include "SignOn/AbstractKeyManager"
43 #include "SignOn/KeyHandler"
44 #include "SignOn/crypto-manager.h"
45
46 /*! @def SIGNON_SECURE_STORAGE_NOT_AVAILABLE
47     Use this event type to signal the CAM when the secure storage is
48     not available. CAM can also reply with a event of this type
49     if it doesn't manage to resolve the secure storage access.
50     @sa SecureStorageEvent
51 */
52 #define SIGNON_SECURE_STORAGE_NOT_AVAILABLE (QEvent::User + 1001)
53
54 /*! @def SIGNON_SECURE_STORAGE_AVAILABLE
55     The CAM will reply with an event of this type when
56     the secure storage access will be successfully resolved.
57     @sa SecureStorageEvent
58 */
59 #define SIGNON_SECURE_STORAGE_AVAILABLE (QEvent::User + 1002)
60
61 /**
62  * Manager access to the Credentials DB - synchronized singleton available everywhere in
63  * the Authentication Core module.
64  */
65 namespace SignonDaemonNS {
66
67 /*!
68     @typedef EventSender Guarded pointer for event sending objects.
69  */
70 typedef QPointer<QObject> EventSender;
71
72 /*!
73     @class SecureStorageEvent
74     Any object in the signon framework that needs the
75     CredentialsAccessManager - CAM -  secure storage in order
76     to function properly can signal this event to the CAM.
77     The object posting this event should reimplement the
78     QObject::customEvent(QEvent *event) method and handle response
79     events of the same type coming from the CAM upon success/failure
80     in resolving access to the secure storage.
81     @sa SIGNON_SECURE_STORAGE_NOT_AVAILABLE
82     @sa SIGNON_SECURE_STORAGE_AVAILABLE
83  */
84 class SecureStorageEvent : public QEvent
85 {
86 public:
87
88     SecureStorageEvent(QEvent::Type type)
89         : QEvent(type),
90           m_sender(0)
91     {}
92
93     EventSender m_sender;    /*! << The sender object of the event. */
94 };
95
96 /*!
97     @class CAMConfiguration
98     Configuration object for the CredentialsAccessManager - CAM.
99     @ingroup Accounts_and_SSO_Framework
100  */
101 struct CAMConfiguration
102 {
103     /*!
104       Constructs a CAMConfiguration object with the default configuration - encryption in use.
105     */
106     CAMConfiguration();
107
108     /*!
109       Serializes the CAMConfiguration object as string to a specific IODevice.
110       @param device, must not be null.
111     */
112     void serialize(QIODevice *device);
113
114     /*!
115      * Returns the path to the metadata DB.
116      */
117     QString metadataDBPath() const;
118
119     /*!
120      * Returns the path of the encrypted FS.
121      */
122     QString encryptedFSPath() const;
123
124     QString m_storagePath;      /*!< The base directory for storage. */
125     QString m_dbName;           /*!< The database file name. */
126     bool m_useEncryption;       /*!< Flag for encryption use, enables/disables all of the bellow. */
127     QString m_fileSystemType;   /*!< The encrypted file system type (ext2, ext3, ext4). */
128     quint32 m_fileSystemSize;   /*!< The encrypted file system size. */
129     QByteArray m_encryptionPassphrase; /*!< Passphrase used for opening encrypted FS. */
130     QString m_encryptedStoragePath; /*!< The directory for encrypted storage. */
131     QString m_aegisPath;        /*!< The base directory for aegisfs. */
132 };
133
134 /*!
135   @enum, error reported by the CAM via the lastError() method.
136 */
137 enum CredentialsAccessError {
138     NoError = 0,
139     NotInitialized,
140     AlreadyInitialized,
141     AccessCodeHandlerInitFailed,
142     AccessCodeNotReady,
143     FailedToFetchAccessCode,
144     AccessCodeInvalid,
145     EncryptionInUse,
146     CredentialsDbSetupFailed,
147     CredentialsDbMountFailed,
148     CredentialsDbUnmountFailed,
149     CredentialsDbDeletionFailed,
150     CredentialsDbAlreadyDeployed,
151     CredentialsDbAlreadyMounted,
152     CredentialsDbNotMounted,
153     CredentialsDbConnectionError,
154     CredentialsDbSqlError,
155     UnknownError
156 };
157
158 /*!
159     @class CredentialsAccessManager
160     Main singleton and manager object of the credentials database system.
161     Offers access to the CredentialsDB and AccessControl objects, using a specific configuration
162     (e.g. Access to a SQL database created on an encrypted file system which is mounted by this system).
163     Most calls of this object's methods return false or NULL in case of
164     failure; the specific error code can be retrieved by calling the
165     lastError() method.
166     @ingroup Accounts_and_SSO_Framework
167     @sa CredentialsDB
168     @sa AccessControl
169     @sa AccessCodeHandler
170     @sa CryptoManager
171  */
172 class CredentialsAccessManager : public QObject
173 {
174     Q_OBJECT
175
176     /*!
177         Constructs a CredentialsAccessManager object with the given parent.
178         @param parent
179     */
180     CredentialsAccessManager(QObject *parent = 0);
181
182     /*!
183        @enum KeySwapAuthorizingMech
184        Core key authorization is performed through key swapping mechanisms.
185        This feature becomes available when the number of inserted authorized keys
186        reaches `0`.
187        - If the mechanism is `Disabled`, signon core will attemp authorizing keys
188        only through available AbstractKeyManager implementations that support
189        key authorization.
190        - If the mechanism is `AuthorizedKeyRemovedFirst`, signon core will attempt
191        authorization of a newly inserted key using its internal already authorized
192        keys collection.
193        - If the mechanism is `UnauthorizedKeyRemovedFirst`, signon core will attempt
194        authorization of a previously disabled unauthorized key, if the last physically
195        inserted key is already authorized. In this case the disabled unauthorized
196        key was cached when disabled, prior to its authorization.
197      */
198     enum KeySwapAuthorizingMech {
199         Disabled = 0,               /**< Signon core does not authorize keys. */
200         AuthorizedKeyRemovedFirst,  /**< The key swap order is as suggested. */
201         UnauthorizedKeyRemovedFirst /**< The key swap order is as suggested. */
202     };
203
204     /*!
205       @enum StorageUiCleanupFlag
206       Specific options for cleaning up resources upon secure storage UI closure.
207       @sa KeySwapAuthorizingMech
208      */
209     enum StorageUiCleanupFlag {
210         NoFlags = 0,                 /**< No flags. */
211         DisableCoreKeyAuthorization  /**< Disable any core key authorization mechanism
212                                           and clears any unauthorized cached key that is
213                                           not physically inserted into the device. */
214     };
215     Q_DECLARE_FLAGS(StorageUiCleanupFlags, StorageUiCleanupFlag)
216
217 public:
218
219     /*!
220         Destroys a CredentialsAccessManager.
221         Closes the credentials access system
222          - closes the database connection
223          - unmounts the dedicated encrypted filesystem, if in use.
224     */
225     ~CredentialsAccessManager();
226
227     /*!
228         Creates the CAM instance with the given parent.
229         @param parent
230     */
231     static CredentialsAccessManager *instance(QObject *parent = 0);
232
233     /*!
234         Initializes the CAM instance with the given configuration.
235         If encryption is in use, this will start the key managers and
236         create the CryptoManager object, preparing everything for the
237         mounting of the encrypted file system.
238         @param configuration
239     */
240     bool init(const CAMConfiguration &configuration = CAMConfiguration());
241
242     /*!
243         Finalizes the CAM instance, this could include, closing the credentials system
244         and resetting the configuration. After this call the CAM needs to be reinitialized.
245     */
246     void finalize();
247
248     /*!
249      * Adds a key manager. This method must be called before init().
250      * @param keyManager The key manager to add.
251      */
252     void addKeyManager(SignOn::AbstractKeyManager *keyManager);
253
254     /*!
255      * Initializes know objects from an extension plugin.
256      * @param extension A signon extension plugin.
257      *
258      * @returns True if the extension provides objects that the CAM is using.
259      */
260 #ifdef SIGNON_AEGISFS
261     bool initExtension(QObject *plugin, bool isDefaultKey = false);
262 #else
263     bool initExtension(QObject *plugin);
264 #endif
265     /*!
266         Opens the credentials system, creates the CreadentialsDB object;
267         if encryption is configured this will also mount the encrypted file system, based on
268         the AccessControlHandler obtained keys.
269         First call of this method on a specific platform also does the
270         formatting prior to the effective opening.
271
272         @returns true on success, false otherwise. Call lastError() to get
273         the error code.
274     */
275     bool openCredentialsSystem();
276
277     /*!
278         Closes the credentials system
279             - closes the database connection
280             - if encryption is in use, unmounts the encrypted file system
281         This is also called by the destructor.
282
283         @returns true on success, false otherwise. Call lastError() to get
284         the error code.
285     */
286     bool closeCredentialsSystem();
287
288     /*!
289         Deletes the credentials system.
290             - deletes the credentials database
291             - if encryption is in use the encrypted file system will be deleted
292         @warning use this carefully. Upon successful completion this call deletes all the stored credentials.
293
294         @returns true on success, false otherwise. Call lastError() to get
295         the error code.
296     */
297     bool deleteCredentialsSystem();
298
299     /*!
300       For convenience method.
301       @returns true if the credentials system is opened, false otherwise.
302     */
303     bool credentialsSystemOpened() const { return m_systemOpened; }
304
305     /*!
306       The creadentials system is ready when all of the subscribed key managers
307       have successfully reported all of the inserted keys. The credentials
308       system can be ready while at the same time the secure storage is not opened.
309       @returns true if the credentials system is ready, false otherwise.
310     */
311     bool isCredentialsSystemReady() const;
312
313     /*!
314       @returns the credentials database object.
315     */
316     CredentialsDB *credentialsDB() const;
317
318     /*!
319       @returns the CAM in use configuration.
320     */
321     const CAMConfiguration &configuration() const { return m_CAMConfiguration; }
322
323     /*!
324       @sa CredentialsAccessError
325       @returns the last CAM's internally reported error.
326     */
327     CredentialsAccessError lastError() const { return m_error; }
328
329     /*!
330       The CAM manages the encryption keys collection.
331       For convenience method.
332       @returns whether the CAM detected any encryption keys or not.
333     */
334     bool keysAvailable() const;
335
336
337     const QString restoreFilePath() const;
338
339     void deleteDefaultKeyStorage() const;
340
341 Q_SIGNALS:
342     /*!
343       Is emitted when the credentials system becomes ready.
344     */
345     void credentialsSystemReady();
346
347 private Q_SLOTS:
348 #ifdef SIGNON_AEGISFS
349     void onKeyHandlerReady();
350 #endif
351     void onKeyInserted(const SignOn::Key key);
352     void onLastAuthorizedKeyRemoved(const SignOn::Key key);
353     void onKeyRemoved(const SignOn::Key key);
354     void onKeyAuthorizationQueried(const SignOn::Key, int);
355     void onEncryptedFSMounted();
356     void onEncryptedFSUnmounting();
357
358 protected:
359     void customEvent(QEvent *event);
360
361 private:
362     bool createStorageDir();
363     bool openSecretsDB();
364     bool isSecretsDBOpen() const;
365     bool closeSecretsDB();
366     bool openMetaDataDB();
367     void closeMetaDataDB();
368     void replyToSecureStorageEventNotifiers();
369
370 private:
371     static CredentialsAccessManager *m_pInstance;
372
373     bool m_isInitialized;
374     bool m_systemOpened;
375     /* Flag indicating whether the system is ready or not.
376      * Currently the system is ready when all of the key managers have
377      * successfully reported all of the inserted keys. */
378     mutable CredentialsAccessError m_error;
379     QList<SignOn::AbstractKeyManager *> keyManagers;
380     QList<SignOn::ExtensionInterface *> keyManagerExtensions;
381
382     CredentialsDB *m_pCredentialsDB;
383     SignOn::CryptoManager *m_pCryptoFileSystemManager;
384     SignOn::KeyHandler *m_keyHandler;
385     SignOn::AbstractKeyAuthorizer *m_keyAuthorizer;
386     CAMConfiguration m_CAMConfiguration;
387
388     /* List of all the senders of a SecureStorageEvent. */
389     QList<EventSender> m_secureStorageEventNotifiers;
390 };
391
392 } //namespace SignonDaemonNS
393
394 #endif // CREDENTIALS_ACCESS_MANAGER_H