cdsa/cdsa_client/securestorage.h

   1 /*
   2  * Copyright (c) 2000-2001 Apple Computer, Inc. All Rights Reserved.
   3  *
   4  * The contents of this file constitute Original Code as defined in and are
   5  * subject to the Apple Public Source License Version 1.2 (the 'License').
   6  * You may not use this file except in compliance with the License. Please obtain
   7  * a copy of the License at http://www.apple.com/publicsource and read it before
   8  * using this file.
   9  *
  10  * This Original Code and all software distributed under the License are
  11  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
  12  * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
  13  * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  14  * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
  15  * specific language governing rights and limitations under the License.
  16  */
  17
  18
  19 //
  20 // securestorage - client interface to CSP DLs and their operations
  21 //
  22 #ifndef _H_CDSA_CLIENT_SECURESTORAGE
  23 #define _H_CDSA_CLIENT_SECURESTORAGE  1
  24
  25 #include <Security/cspclient.h>
  26 #include <Security/dlclient.h>
  27 #include <Security/keyclient.h>
  28
  29 namespace Security
  30 {
  31
  32 namespace CssmClient
  33 {
  34
  35 //
  36 // A CSP and a DL attachment of the same subservice
  37 //
  38 // This gives us 2 Object instances, but we make sure that have the same
  39 // mImpl.  Currently this class has no behaviour, but it will get some in
  40 // the future.
  41 //
  42 class CSPDLImpl : public CSPImpl, public DLImpl
  43 {
  44 public:
  45         CSPDLImpl(const Guid &guid);
  46         CSPDLImpl(const Module &module);
  47         virtual ~CSPDLImpl();
  48
  49         // Object methods.
  50         bool isActive() const { return CSPImpl::isActive() || DLImpl::isActive(); }
  51
  52         virtual CssmAllocator &allocator() const;
  53         virtual void allocator(CssmAllocator &alloc);
  54
  55         virtual bool operator <(const CSPDLImpl &other) const;
  56         virtual bool operator ==(const CSPDLImpl &other) const;
  57
  58         // Attachment methods.
  59         virtual CSSM_SERVICE_MASK subserviceMask() const;
  60         virtual void subserviceId(uint32 id);
  61
  62         uint32 subserviceId() const { return CSPImpl::subserviceId(); }
  63         CSSM_ATTACH_FLAGS cspFlags() const { return CSPImpl::flags(); }
  64         void cspFlags(CSSM_ATTACH_FLAGS f) { CSPImpl::flags(f); }
  65         CSSM_ATTACH_FLAGS dlFlags() const { return DLImpl::flags(); }
  66         void dlFlags(CSSM_ATTACH_FLAGS f) { DLImpl::flags(f); }
  67
  68         void attach() { CSPImpl::attach(); DLImpl::attach(); }
  69         void detach() { CSPImpl::detach(); DLImpl::detach(); }
  70         bool attached() const { return CSPImpl::attached() || DLImpl::attached(); }
  71
  72         Module module() const { return CSPImpl::module(); }
  73         const Guid &guid() const { return CSPImpl::guid(); }
  74         CSSM_MODULE_HANDLE cspHandle() { return CSPImpl::handle(); }
  75         CSSM_MODULE_HANDLE dlHandle() { return DLImpl::handle(); }
  76
  77         CssmSubserviceUid subserviceUid() const
  78         { return CSPImpl::subserviceUid(); }
  79
  80 private:
  81 };
  82
  83
  84 class CSPDL : public CSP, public DL
  85 {
  86 public:
  87         typedef CSPDLImpl Impl;
  88
  89         explicit CSPDL(Impl *impl) : CSP(impl), DL(impl) {}
  90         CSPDL(const Guid &guid) : CSP(new Impl(guid)), DL(&CSP::impl<Impl>()) {}
  91         CSPDL(const Module &module)
  92                 : CSP(new Impl(module)), DL(&CSP::impl<Impl>()) {}
  93
  94         //template <class _Impl> _Impl &impl() const
  95         //{ return CSP::impl<_Impl>(); }
  96
  97         Impl *get() const { return &CSP::impl<Impl>(); }
  98         Impl *operator ->() const { return &CSP::impl<Impl>(); }
  99         Impl &operator *() const { return CSP::impl<Impl>(); }
 100
 101         // Conversion operators must be here
 102         bool operator !() const { return !get(); }
 103         operator bool() const { return get(); }
 104
 105         bool operator <(const CSPDL &other) const
 106         { return *this && other ? **this < *other : get() < other.get(); }
 107         bool operator ==(const CSPDL &other) const
 108         { return *this && other ? **this == *other : get() == other.get(); }
 109 };
 110
 111
 112 //
 113 // SSCSPDL -- Secure storage class
 114 //
 115 class SSCSPDLImpl : public CSPDLImpl
 116 {
 117 public:
 118         SSCSPDLImpl(const Guid &guid);
 119         SSCSPDLImpl(const Module &module);
 120         virtual ~SSCSPDLImpl();
 121
 122         // DbMaker
 123         DbImpl *newDb(const char *inDbName, const CSSM_NET_ADDRESS *inDbLocation);
 124 private:
 125 };
 126
 127 class SSCSPDL : public CSPDL
 128 {
 129 public:
 130         typedef SSCSPDLImpl Impl;
 131
 132         explicit SSCSPDL(Impl *impl) : CSPDL(impl) {}
 133         SSCSPDL(const Guid &guid) : CSPDL(new Impl(guid)) {}
 134         SSCSPDL(const Module &module) : CSPDL(new Impl(module)) {}
 135
 136         Impl *operator ->() const { return &CSP::impl<Impl>(); }
 137         Impl &operator *() const { return CSP::impl<Impl>(); }
 138 };
 139
 140
 141 //
 142 // SSDbImpl --  A Security Storage Db object.
 143 //
 144 class SSGroup;
 145 class SSDbUniqueRecord;
 146
 147 class SSDbImpl : public DbImpl
 148 {
 149 public:
 150         SSDbImpl(const SSCSPDL &cspdl,
 151                          const char *inDbName, const CSSM_NET_ADDRESS *inDbLocation);
 152         virtual ~SSDbImpl();
 153
 154         void create();
 155         void open();
 156
 157         SSDbUniqueRecord insert(CSSM_DB_RECORDTYPE recordType,
 158                                                         const CSSM_DB_RECORD_ATTRIBUTE_DATA *attributes,
 159                                                         const CSSM_DATA *data,
 160                                                         const CSSM_RESOURCE_CONTROL_CONTEXT *rc = NULL);
 161
 162 #if 0
 163         SSDbUniqueRecord insert(CSSM_DB_RECORDTYPE recordType,
 164                                                         const CSSM_DB_RECORD_ATTRIBUTE_DATA *attributes,
 165                                                         const CSSM_DATA *data,
 166                                                         const AutoAclEntryInfoList &keyAcl);
 167 #endif
 168
 169         SSDbUniqueRecord insert(CSSM_DB_RECORDTYPE recordType,
 170                                                         const CSSM_DB_RECORD_ATTRIBUTE_DATA *attributes,
 171                                                         const CSSM_DATA *data, const SSGroup &group,
 172                                                         const CSSM_ACCESS_CREDENTIALS *cred);
 173
 174         // DbCursorMaker
 175         DbCursorImpl *newDbCursor(const CSSM_QUERY &query,
 176                                                           CssmAllocator &allocator);
 177         DbCursorImpl *newDbCursor(uint32 capacity, CssmAllocator &allocator);
 178
 179         // SSDbUniqueRecordMaker
 180         DbUniqueRecordImpl *newDbUniqueRecord();
 181
 182         CSP csp() { return parent<CSP>(); }
 183 };
 184
 185 class SSDb : public Db
 186 {
 187 public:
 188         typedef SSDbImpl Impl;
 189
 190         explicit SSDb(Impl *impl) : Db(impl) {}
 191         SSDb(const SSCSPDL &cspdl, const char *inDbName,
 192                  const CSSM_NET_ADDRESS *inDbLocation)
 193                 : Db(cspdl->newDb(inDbName, inDbLocation)) {}
 194
 195         Impl *operator ->() const { return &impl<Impl>(); }
 196         Impl &operator *() const { return impl<Impl>(); }
 197 };
 198
 199
 200 //
 201 // SSGroup -- Group key with acl, used to protect a group of items.
 202 //
 203 class SSGroupImpl : public KeyImpl
 204 {
 205 public:
 206         SSGroupImpl(const SSDb &ssDb, const CSSM_DATA &dataBlob);
 207         SSGroupImpl(const SSDb &ssDb,
 208                                 const CSSM_RESOURCE_CONTROL_CONTEXT *credAndAclEntry);
 209
 210         static bool isGroup(const CSSM_DATA &dataBlob);
 211
 212         const CssmData label() const;
 213         void decodeDataBlob(const CSSM_DATA &dataBlob,
 214                                                 const CSSM_ACCESS_CREDENTIALS *cred,
 215                                                 CssmAllocator &allocator, CSSM_DATA &data);
 216         void encodeDataBlob(const CSSM_DATA *data,
 217                                                 const CSSM_ACCESS_CREDENTIALS *cred,
 218                                                 CssmDataContainer &dataBlob);
 219
 220 private:
 221         // Constants
 222         enum
 223         {
 224                 // Label prefix for a secure storage group
 225                 kGroupMagic = FOUR_CHAR_CODE('ssgp'),
 226
 227                 // Size of label (including prefix)
 228                 kLabelSize = 20,
 229
 230                 // Size of IV
 231                 kIVSize = 8
 232         };
 233
 234         CSSM_DB_ATTR_DECL(kLabel);
 235
 236         CssmDataContainer mLabel;
 237 };
 238
 239 class SSGroup : public Key
 240 {
 241 public:
 242         typedef SSGroupImpl Impl;
 243         explicit SSGroup(Impl *impl) : Key(impl) {}
 244
 245         SSGroup() : Key(NULL) {}
 246
 247         // Create a new group.
 248         SSGroup(const SSDb &ssDb,
 249                         const CSSM_RESOURCE_CONTROL_CONTEXT *credAndAclEntry)
 250         : Key(new Impl(ssDb, credAndAclEntry)) {}
 251
 252         // Lookup an existing group based on a dataBlob.
 253         SSGroup(const SSDb &ssDb, const CSSM_DATA &dataBlob)
 254         : Key(new Impl(ssDb, dataBlob)) {}
 255
 256         Impl *operator ->() const { return &impl<Impl>(); }
 257         Impl &operator *() const { return impl<Impl>(); }
 258 };
 259
 260
 261 //
 262 // SSDbCursor -- Cursor for iterating over Securely Stored records (or keys)
 263 //
 264 class SSDbCursorImpl : public DbDbCursorImpl
 265 {
 266 public:
 267         SSDbCursorImpl(const Db &db, const CSSM_QUERY &query,
 268                                    CssmAllocator &allocator);
 269         SSDbCursorImpl(const Db &db, uint32 capacity,
 270                                    CssmAllocator &allocator);
 271
 272         bool next(DbAttributes *attributes, ::CssmDataContainer *data,
 273                           DbUniqueRecord &uniqueId);
 274         bool next(DbAttributes *attributes, ::CssmDataContainer *data,
 275                           DbUniqueRecord &uniqueId, const CSSM_ACCESS_CREDENTIALS *cred);
 276         bool nextKey(DbAttributes *attributes, Key &key, DbUniqueRecord &uniqueId);
 277         //bool nextGroup(DbAttributes *attributes, SSGroup &group, DbUniqueRecord &uniqueId);
 278
 279         SSDb database() { return parent<SSDb>(); }
 280 protected:
 281         void activate();
 282         void deactivate();
 283 };
 284
 285 class SSDbCursor : public DbCursor
 286 {
 287 public:
 288         typedef SSDbCursorImpl Impl;
 289
 290         explicit SSDbCursor(Impl *impl) : DbCursor(impl) {}
 291         SSDbCursor(const SSDb &ssDb, const CSSM_QUERY &query,
 292                            CssmAllocator &allocator = CssmAllocator::standard())
 293                 : DbCursor(ssDb->newDbCursor(query, allocator)) {}
 294         SSDbCursor(const SSDb &ssDb, const uint32 capacity = 0,
 295                            CssmAllocator &allocator = CssmAllocator::standard())
 296                 : DbCursor(ssDb->newDbCursor(capacity, allocator)) {}
 297
 298         Impl *operator ->() const { return &impl<Impl>(); }
 299         Impl &operator *() const { return impl<Impl>(); }
 300 };
 301
 302
 303 //
 304 // SSDbUniqueRecord
 305 //
 306 class SSDbUniqueRecordImpl : public DbUniqueRecordImpl
 307 {
 308 public:
 309         SSDbUniqueRecordImpl(const Db &db);
 310         virtual ~SSDbUniqueRecordImpl();
 311
 312         void deleteRecord();
 313         void deleteRecord(const CSSM_ACCESS_CREDENTIALS *cred);
 314         void modify(CSSM_DB_RECORDTYPE recordType,
 315                                 const CSSM_DB_RECORD_ATTRIBUTE_DATA *attributes,
 316                                 const CSSM_DATA *data,
 317                                 CSSM_DB_MODIFY_MODE modifyMode);
 318         void modify(CSSM_DB_RECORDTYPE recordType,
 319                                 const CSSM_DB_RECORD_ATTRIBUTE_DATA *attributes,
 320                                 const CSSM_DATA *data,
 321                                 CSSM_DB_MODIFY_MODE modifyMode,
 322                                 const CSSM_ACCESS_CREDENTIALS *cred);
 323         void get(DbAttributes *attributes, ::CssmDataContainer *data);
 324         void get(DbAttributes *attributes, ::CssmDataContainer *data,
 325                          const CSSM_ACCESS_CREDENTIALS *cred);
 326
 327         SSDb database() { return parent<SSDb>(); }
 328
 329         // Return the group that this record is in.
 330         SSGroup group();
 331 };
 332
 333 class SSDbUniqueRecord : public DbUniqueRecord
 334 {
 335 public:
 336         typedef SSDbUniqueRecordImpl Impl;
 337
 338         explicit SSDbUniqueRecord(Impl *impl) : DbUniqueRecord(impl) {}
 339         SSDbUniqueRecord(const SSDb &ssDb)
 340                 : DbUniqueRecord(ssDb->newDbUniqueRecord()) {}
 341
 342         Impl *operator ->() const { return &impl<Impl>(); }
 343         Impl &operator *() const { return impl<Impl>(); }
 344 };
 345
 346 }; // end namespace CssmClient
 347
 348 } // end namespace Security
 349
 350 #endif //_H_CDSA_CLIENT_SECURESTORAGE