CryptoManager: add fileSystemIsSetup()
[accounts-sso: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 "cryptomanager.h"
36 #include "signonui_interface.h"
37
38 #include <QObject>
39 #include <QPointer>
40 #include <QFlags>
41
42 #include "SignOn/AbstractKeyManager"
43
44 /*! @def SIGNON_SECURE_STORAGE_NOT_AVAILABLE
45     Use this event type to signal the CAM when the secure storage is
46     not available. CAM can also reply with a event of this type
47     if it doesn't manage to resolve the secure storage access.
48     @sa SecureStorageEvent
49 */
50 #define SIGNON_SECURE_STORAGE_NOT_AVAILABLE (QEvent::User + 1001)
51
52 /*! @def SIGNON_SECURE_STORAGE_AVAILABLE
53     The CAM will reply with an event of this type when
54     the secure storage access will be successfully resolved.
55     @sa SecureStorageEvent
56 */
57 #define SIGNON_SECURE_STORAGE_AVAILABLE (QEvent::User + 1002)
58
59 /**
60  * Manager access to the Credentials DB - synchronized singleton available everywhere in
61  * the Authentication Core module.
62  */
63 namespace SignonDaemonNS {
64
65 /*!
66     @typedef EventSender Guarded pointer for event sending objects.
67  */
68 typedef QPointer<QObject> EventSender;
69
70 /*!
71     @class SecureStorageEvent
72     Any object in the signon framework that needs the
73     CredentialsAccessManager - CAM -  secure storage in order
74     to function properly can signal this event to the CAM.
75     The object posting this event should reimplement the
76     QObject::customEvent(QEvent *event) method and handle response
77     events of the same type coming from the CAM upon success/failure
78     in resolving access to the secure storage.
79     @sa SIGNON_SECURE_STORAGE_NOT_AVAILABLE
80     @sa SIGNON_SECURE_STORAGE_AVAILABLE
81  */
82 class SecureStorageEvent : public QEvent
83 {
84 public:
85
86     SecureStorageEvent(QEvent::Type type)
87         : QEvent(type),
88           m_sender(0)
89     {}
90
91     EventSender m_sender;    /*! << The sender object of the event. */
92 };
93
94 /*!
95     @class CAMConfiguration
96     Configuration object for the CredentialsAccessManager - CAM.
97     @ingroup Accounts_and_SSO_Framework
98  */
99 struct CAMConfiguration
100 {
101     /*!
102       Constructs a CAMConfiguration object with the default configuration - encryption in use.
103     */
104     CAMConfiguration();
105
106     /*!
107       Serializes the CAMConfiguration object as string to a specific IODevice.
108       @param device, must not be null.
109     */
110     void serialize(QIODevice *device);
111
112     /*!
113      * Returns the path to the metadata DB.
114      */
115     QString metadataDBPath() const;
116
117     /*!
118      * Returns the path of the encrypted FS.
119      */
120     QString encryptedFSPath() const;
121
122     QString m_storagePath;      /*!< The base directory for storage. */
123     QString m_dbName;           /*!< The database file name. */
124     bool m_useEncryption;       /*!< Flag for encryption use, enables/disables all of the bellow. */
125     QString m_fileSystemType;   /*!< The encrypted file system type (ext2, ext3, ext4). */
126     quint32 m_fileSystemSize;   /*!< The encrypted file system size. */
127     QByteArray m_encryptionPassphrase; /*!< Passphrase used for opening encrypted FS. */
128 };
129
130 /*!
131   @enum, error reported by the CAM via the lastError() method.
132 */
133 enum CredentialsAccessError {
134     NoError = 0,
135     NotInitialized,
136     AlreadyInitialized,
137     AccessCodeHandlerInitFailed,
138     AccessCodeNotReady,
139     FailedToFetchAccessCode,
140     AccessCodeInvalid,
141     EncryptionInUse,
142     CredentialsDbSetupFailed,
143     CredentialsDbMountFailed,
144     CredentialsDbUnmountFailed,
145     CredentialsDbDeletionFailed,
146     CredentialsDbAlreadyDeployed,
147     CredentialsDbAlreadyMounted,
148     CredentialsDbNotMounted,
149     CredentialsDbConnectionError,
150     CredentialsDbSqlError,
151     UnknownError
152 };
153
154 /*!
155     @class CredentialsAccessManager
156     Main singleton and manager object of the credentials database system.
157     Offers access to the CredentialsDB and AccessControl objects, using a specific configuration
158     (e.g. Access to a SQL database created on an encrypted file system which is mounted by this system).
159     Most calls of this object's methods return false or NULL in case of
160     failure; the specific error code can be retrieved by calling the
161     lastError() method.
162     @ingroup Accounts_and_SSO_Framework
163     @sa CredentialsDB
164     @sa AccessControl
165     @sa AccessCodeHandler
166     @sa CryptoManager
167  */
168 class CredentialsAccessManager : public QObject
169 {
170     Q_OBJECT
171
172     /*!
173         Constructs a CredentialsAccessManager object with the given parent.
174         @param parent
175     */
176     CredentialsAccessManager(QObject *parent = 0);
177
178     /*!
179        @enum KeySwapAuthorizingMech
180        Core key authorization is performed through key swapping mechanisms.
181        This feature becomes available when the number of inserted authorized keys
182        reaches `0`.
183        - If the mechanism is `Disabled`, signon core will attemp authorizing keys
184        only through available AbstractKeyManager implementations that support
185        key authorization.
186        - If the mechanism is `AuthorizedKeyRemovedFirst`, signon core will attempt
187        authorization of a newly inserted key using its internal already authorized
188        keys collection.
189        - If the mechanism is `UnauthorizedKeyRemovedFirst`, signon core will attempt
190        authorization of a previously disabled unauthorized key, if the last physically
191        inserted key is already authorized. In this case the disabled unauthorized
192        key was cached when disabled, prior to its authorization.
193      */
194     enum KeySwapAuthorizingMech {
195         Disabled = 0,               /**< Signon core does not authorize keys. */
196         AuthorizedKeyRemovedFirst,  /**< The key swap order is as suggested. */
197         UnauthorizedKeyRemovedFirst /**< The key swap order is as suggested. */
198     };
199
200     /*!
201       @enum StorageUiCleanupFlag
202       Specific options for cleaning up resources upon secure storage UI closure.
203       @sa KeySwapAuthorizingMech
204      */
205     enum StorageUiCleanupFlag {
206         NoFlags = 0,                 /**< No flags. */
207         DisableCoreKeyAuthorization  /**< Disable any core key authorization mechanism
208                                           and clears any unauthorized cached key that is
209                                           not physically inserted into the device. */
210     };
211     Q_DECLARE_FLAGS(StorageUiCleanupFlags, StorageUiCleanupFlag)
212
213 public:
214
215     /*!
216         Destroys a CredentialsAccessManager.
217         Closes the credentials access system
218          - closes the database connection
219          - unmounts the dedicated encrypted filesystem, if in use.
220     */
221     ~CredentialsAccessManager();
222
223     /*!
224         Creates the CAM instance with the given parent.
225         @param parent
226     */
227     static CredentialsAccessManager *instance(QObject *parent = 0);
228
229     /*!
230         Initializes the CAM instance with the given configuration.
231         If encryption is in use, this will start the key managers and
232         create the CryptoManager object, preparing everything for the
233         mounting of the encrypted file system.
234         @param configuration
235     */
236     bool init(const CAMConfiguration &configuration = CAMConfiguration());
237
238     /*!
239         Finalizes the CAM instance, this could include, closing the credentials system
240         and resetting the configuration. After this call the CAM needs to be reinitialized.
241     */
242     void finalize();
243
244     /*!
245      * Adds a key manager. This method must be called before init().
246      * @param keyManager The key manager to add.
247      */
248     void addKeyManager(SignOn::AbstractKeyManager *keyManager);
249
250     /*!
251         Opens the credentials system, creates the CreadentialsDB object;
252         if encryption is configured this will also mount the encrypted file system, based on
253         the AccessControlHandler obtained keys.
254         First call of this method on a specific platform also does the
255         formatting prior to the effective opening.
256
257         @returns true on success, false otherwise. Call lastError() to get
258         the error code.
259     */
260     bool openCredentialsSystem();
261
262     /*!
263         Closes the credentials system
264             - closes the database connection
265             - if encryption is in use, unmounts the encrypted file system
266         This is also called by the destructor.
267
268         @returns true on success, false otherwise. Call lastError() to get
269         the error code.
270     */
271     bool closeCredentialsSystem();
272
273     /*!
274         Deletes the credentials system.
275             - deletes the credentials database
276             - if encryption is in use the encrypted file system will be deleted
277         @warning use this carefully. Upon successful completion this call deletes all the stored credentials.
278
279         @returns true on success, false otherwise. Call lastError() to get
280         the error code.
281     */
282     bool deleteCredentialsSystem();
283
284     /*!
285       For convenience method.
286       @returns true if the credentials system is opened, false otherwise.
287     */
288     bool credentialsSystemOpened() const { return m_systemOpened; }
289
290     /*!
291       The creadentials system is ready when all of the subscribed key managers
292       have successfully reported all of the inserted keys. The credentials
293       system can be ready while at the same time the secure storage is not opened.
294       @returns true if the credentials system is ready, false otherwise.
295     */
296     bool isCredentialsSystemReady() const { return m_systemReady; }
297
298     /*!
299       @returns the credentials database object.
300     */
301     CredentialsDB *credentialsDB() const;
302
303     /*!
304       @returns the CAM in use configuration.
305     */
306     const CAMConfiguration &configuration() const { return m_CAMConfiguration; }
307
308     /*!
309       @sa CredentialsAccessError
310       @returns the last CAM's internally reported error.
311     */
312     CredentialsAccessError lastError() const { return m_error; }
313
314     /*!
315       The CAM manages the encryption keys collection.
316       For convenience method.
317       @returns whether the CAM detected any encryption keys or not.
318     */
319     bool keysAvailable() const;
320
321 Q_SIGNALS:
322     /*!
323       Is emitted when the credentials system becomes ready.
324     */
325     void credentialsSystemReady();
326
327 private Q_SLOTS:
328     void onKeyInserted(const SignOn::Key key);
329     void onKeyDisabled(const SignOn::Key key);
330     void onKeyRemoved(const SignOn::Key key);
331     void onKeyAuthorized(const SignOn::Key key, bool authorized);
332     void onClearPasswordsStorage();
333     void onSecureStorageUiRejected();
334     void onNoKeyPresentAccepted();
335     void onEncryptedFSMounted();
336     void onEncryptedFSUnmounting();
337
338 protected:
339     void customEvent(QEvent *event);
340
341 private:
342     // 1st time start - deploys the database.
343     void initKeyManagers();
344     bool deployCredentialsSystem();
345     bool openSecretsDB();
346     bool isSecretsDBOpen();
347     bool closeSecretsDB();
348     bool openMetaDataDB();
349     void closeMetaDataDB();
350     void queryEncryptionKeys();
351     void replyToSecureStorageEventNotifiers();
352     bool processSecureStorageEvent();
353
354     void onSecureStorageUiClosed(const StorageUiCleanupFlags flags = NoFlags);
355
356     /*!
357      * Checks if the key can open the secure storage. If it can, the file system
358      * is also mounted and the secrets' storage is opened.
359      */
360     bool encryptionKeyCanOpenStorage(const QByteArray &key);
361
362     /*!
363       Checks if core ecryption key authorizing is enabled using a specific
364       key swap authorizing mechanism.
365       @param mech The mechanism to be checked.
366       @returns true if the specific mechanism is enabled, false if otherwise
367                or no mechanism is enabled at all. This method will always return
368                false if `mech` is `KeySwapAuthorizingMech::Disabled`.
369     */
370     bool coreKeyAuthorizingEnabled(const KeySwapAuthorizingMech mech) const;
371
372     /*!
373       Sets the core encryption key authorization mechanism.
374       @param mech The authorization mechanism.
375     */
376     void setCoreKeyAuthorizationMech(const KeySwapAuthorizingMech mech);
377
378     /*!
379       @returns the set of currently inserted authorized keys.
380     */
381     QSet<SignOn::Key> authorizedInsertedKeys() const;
382
383 private:
384     static CredentialsAccessManager *m_pInstance;
385
386     bool m_isInitialized;
387     bool m_systemOpened;
388     /* Flag indicating whether the system is ready or not.
389      * Currently the system is ready when all of the key managers have
390      * successfully reported all of the inserted keys. */
391     bool m_systemReady;
392     mutable CredentialsAccessError m_error;
393     QList<SignOn::AbstractKeyManager *> keyManagers;
394
395     /* Counter for the key managers that are ready
396      * - have signaled at least one key (can be empty).
397      * This helps in computing when the CAM is ready;
398      * see also credentialsSystemReady(). */
399     int readyKeyManagersCounter;
400
401     /* Collection of authorized keys, gathered through the lifetime of the
402      * signond process. */
403     QList<SignOn::Key> authorizedKeys;
404     /* Collection of physically inserted keys at a specific runtime moment. */
405     QList<SignOn::Key> insertedKeys;
406
407     /* Flag indicating if the CAM is in the middle of processing
408      * a secure storage event. */
409     bool processingSecureStorageEvent;
410     /* This member will cache the lastly disabled unauthorized
411      * key. The cached key will be cleared if any secure storage UI
412      * disaplyed at its removal time is closed by the user.
413      * Check the KeySwapAuthorizingMech::UnauthorizedKeyRemovedFirst
414      * documentation for additional details. */
415     QByteArray cachedUnauthorizedKey;
416
417     /* Check the KeySwapAuthorizingMech definitions' documentation. */
418     KeySwapAuthorizingMech keySwapAuthorizingMechanism;
419
420     CredentialsDB *m_pCredentialsDB;
421     CryptoManager *m_pCryptoFileSystemManager;
422     CAMConfiguration m_CAMConfiguration;
423
424     /* List of all the senders of a SecureStorageEvent. */
425     QList<EventSender> m_secureStorageEventNotifiers;
426
427     SignonSecureStorageUiAdaptor *m_secureStorageUiAdaptor;
428 };
429
430 } //namespace SignonDaemonNS
431
432 #endif // CREDENTIALS_ACCESS_MANAGER_H