securityd/src/database.h

   1 /*
   2  * Copyright (c) 2000-2008 Apple Inc. All Rights Reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24
  25 //
  26 // database - abstract database management
  27 //
  28 // This file defines database objects that represent different
  29 // way to implement "database with cryptographic operations on its contents".
  30 // The objects here are abstract and need to be implemented to be useful.
  31 //
  32 #ifndef _H_DATABASE
  33 #define _H_DATABASE
  34
  35 #include "structure.h"
  36 #include "acls.h"
  37 #include "dbcrypto.h"
  38 #include "notifications.h"
  39 #include <security_utilities/utilities.h>
  40 #include <security_cdsa_utilities/u32handleobject.h>
  41 #include <security_cdsa_utilities/cssmdb.h>
  42 #include <security_utilities/machserver.h>
  43 #include <security_utilities/timeflow.h>
  44 #include <string>
  45 #include <map>
  46
  47
  48 class Key;
  49 class Connection;
  50 class Process;
  51 class Session;
  52 using MachPlusPlus::MachServer;
  53
  54
  55 //
  56 // A Database::DbCommon is the "common core" of all Database objects that
  57 // represent the same client database (on disk, presumably).
  58 // NOTE: DbCommon obeys exterior locking protocol: the caller (always Database)
  59 // must lock it before operating on its non-const members. In practice,
  60 // most Database methods lock down their DbCommon first thing.
  61 //
  62 class DbCommon : public PerSession {
  63 public:
  64         DbCommon(Session &ssn);
  65
  66         Session &session() const;
  67
  68         virtual void sleepProcessing();         // generic action on system sleep
  69         virtual void lockProcessing();          // generic action on "lock" requests
  70
  71         virtual bool belongsToSystem() const; // belongs to system (root) security domain
  72
  73     virtual uint32 dbVersion() = 0;     // For databases that have a concept of version, return the version
  74
  75 protected:
  76         void notify(NotificationEvent event, const DLDbIdentifier &ident);
  77 };
  78
  79
  80 //
  81 // A Database object represents an Apple CSP/DL open database (DL/DB) object.
  82 // It maintains its protected semantic state (including keys) and provides controlled
  83 // access.
  84 //
  85 class Database : public PerProcess, public AclSource {
  86     static const NotificationEvent lockedEvent = kNotificationEventLocked;
  87     static const NotificationEvent unlockedEvent = kNotificationEventUnlocked;
  88     static const NotificationEvent passphraseChangedEvent = kNotificationEventPassphraseChanged;
  89
  90 protected:
  91         Database(Process &proc);
  92
  93 public:
  94         Process& process() const;
  95
  96         virtual bool transient() const = 0;                     // is transient store (reboot clears)
  97
  98 public:
  99         //
 100         // A common class for objects that "belong" to a Database and
 101         // don't have parents up the global stack. These will die along with
 102         // the Database when it goes.
 103         //
 104         class Subsidiary : public PerProcess {
 105         public:
 106                 Subsidiary(Database &db) { referent(db); }
 107                 Database &database() const { return referent<Database>(); }
 108                 Process &process() const { return database().process(); }
 109         };
 110
 111         //
 112         // Cryptographic service calls.
 113         // These must be supported by any type of database.
 114         //
 115         virtual void releaseKey(Key &key);
 116     virtual void queryKeySizeInBits(Key &key, CssmKeySize &result) = 0;
 117     virtual void getOutputSize(const Context &context, Key &key,
 118                 uint32 inputSize, bool encrypt, uint32 &result) = 0;
 119
 120         virtual void generateSignature(const Context &context, Key &key,
 121                 CSSM_ALGORITHMS signOnlyAlgorithm, const CssmData &data, CssmData &signature) = 0;
 122         virtual void verifySignature(const Context &context, Key &key,
 123                 CSSM_ALGORITHMS verifyOnlyAlgorithm, const CssmData &data, const CssmData &signature) = 0;
 124         virtual void generateMac(const Context &context, Key &key,
 125                 const CssmData &data, CssmData &mac) = 0;
 126         virtual void verifyMac(const Context &context, Key &key,
 127                 const CssmData &data, const CssmData &mac) = 0;
 128
 129         virtual void encrypt(const Context &context, Key &key, const CssmData &clear, CssmData &cipher) = 0;
 130         virtual void decrypt(const Context &context, Key &key, const CssmData &cipher, CssmData &clear) = 0;
 131
 132         virtual void generateKey(const Context &context,
 133                 const AccessCredentials *cred, const AclEntryPrototype *owner,
 134                 uint32 usage, uint32 attrs, RefPointer<Key> &newKey) = 0;
 135         virtual void generateKey(const Context &context,
 136                 const AccessCredentials *cred, const AclEntryPrototype *owner,
 137                 uint32 pubUsage, uint32 pubAttrs, uint32 privUsage, uint32 privAttrs,
 138                 RefPointer<Key> &publicKey, RefPointer<Key> &privateKey) = 0;
 139
 140     virtual void wrapKey(const Context &context, const AccessCredentials *cred,
 141                 Key *wrappingKey, Key &keyToBeWrapped,
 142         const CssmData &descriptiveData, CssmKey &wrappedKey) = 0;
 143         virtual void unwrapKey(const Context &context,
 144                 const AccessCredentials *cred, const AclEntryPrototype *owner,
 145                 Key *wrappingKey, Key *publicKey, CSSM_KEYUSE usage, CSSM_KEYATTR_FLAGS attrs,
 146                 const CssmKey wrappedKey, RefPointer<Key> &unwrappedKey, CssmData &descriptiveData) = 0;
 147         virtual void deriveKey(const Context &context, Key *key,
 148                 const AccessCredentials *cred, const AclEntryPrototype *owner,
 149                 CssmData *param, uint32 usage, uint32 attrs, RefPointer<Key> &derivedKey) = 0;
 150
 151         virtual void authenticate(CSSM_DB_ACCESS_TYPE mode, const AccessCredentials *cred);
 152
 153     // returns true if these credentials contain a valid password or master key for this database
 154     virtual bool checkCredentials(const AccessCredentials *cred);
 155         virtual SecurityServerAcl &acl();
 156
 157         virtual bool isLocked();
 158
 159 public:
 160         class Search : public Subsidiary {
 161         public:
 162                 Search(Database &db) : Subsidiary(db) { }
 163         };
 164
 165         class Record : public Subsidiary {
 166         public:
 167                 Record(Database &db) : Subsidiary(db) { }
 168         };
 169
 170         virtual void findFirst(const CssmQuery &query,
 171                 CssmDbRecordAttributeData *inAttributes, mach_msg_type_number_t inAttributesLength,
 172                 CssmData *data, RefPointer<Key> &key, RefPointer<Search> &search,
 173                 RefPointer<Record> &record,
 174                 CssmDbRecordAttributeData * &outAttributes, mach_msg_type_number_t &outAttributesLength);
 175         virtual void findNext(Search *search,
 176                 CssmDbRecordAttributeData *inAttributes, mach_msg_type_number_t inAttributesLength,
 177                 CssmData *data, RefPointer<Key> &key, RefPointer<Record> &record,
 178                 CssmDbRecordAttributeData * &outAttributes, mach_msg_type_number_t &outAttributesLength);
 179         virtual void findRecordHandle(Record *record,
 180                 CssmDbRecordAttributeData *inAttributes, mach_msg_type_number_t inAttributesLength,
 181                 CssmData *data, RefPointer<Key> &key,
 182                 CssmDbRecordAttributeData * &outAttributes, mach_msg_type_number_t &outAttributesLength);
 183
 184         virtual void insertRecord(CSSM_DB_RECORDTYPE recordtype,
 185                 const CssmDbRecordAttributeData *attributes, mach_msg_type_number_t inAttributesLength,
 186                 const CssmData &data, RecordHandle &record);
 187         virtual void modifyRecord(CSSM_DB_RECORDTYPE recordtype, Record *record,
 188                 const CssmDbRecordAttributeData *attributes, mach_msg_type_number_t inAttributesLength,
 189                 const CssmData *data, CSSM_DB_MODIFY_MODE modifyMode);
 190         virtual void deleteRecord(Database::Record *record);
 191
 192         virtual void releaseSearch(Search &search);
 193         virtual void releaseRecord(Record &record);
 194
 195 public:
 196         // SecurityServerAcl personality
 197         AclKind aclKind() const;
 198         Database *relatedDatabase();
 199
 200         bool belongsToSystem() const { return common().belongsToSystem(); }
 201
 202 public:
 203         // support ACL remote secret validation (default is no support)
 204         virtual bool validateSecret(const AclSubject *subject, const AccessCredentials *cred);
 205
 206 public:
 207         static const int maxUnlockTryCount = 3;
 208
 209 public:
 210         DbCommon& common() const                        { return parent<DbCommon>(); }
 211         virtual const char *dbName() const = 0;
 212         virtual void dbName(const char *name);
 213
 214     virtual uint32 dbVersion() { return common().dbVersion(); }
 215
 216     // Check if this database is in the middle of a recode/migration
 217     virtual bool isRecoding() { return false; }
 218 };
 219
 220 #endif //_H_DATABASE