OSX/libsecurity_cdsa_utilities/lib/cssmdb.cpp

   1 /*
   2  * Copyright (c) 2000-2004,2006,2011-2012,2014 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 // cssmdb.cpp
  26 //
  27 //
  28 #include <security_cdsa_utilities/cssmdb.h>
  29 #include <CommonCrypto/CommonDigest.h>
  30
  31 using namespace DataWalkers;
  32
  33 bool DLDbIdentifier::Impl::operator < (const DLDbIdentifier::Impl &other) const
  34 {
  35     if (mCssmSubserviceUid < other.mCssmSubserviceUid)
  36         return true;
  37     if (mCssmSubserviceUid != other.mCssmSubserviceUid) // i.e. greater than
  38         return false;
  39
  40     // This test will produce unreproducible results,
  41     // depending on what items are being compared.  To do this properly, we need to
  42     // assign a lexical value to NULL.
  43     //
  44     // if (mDbName.canonicalName() == NULL || other.mDbName.canonicalName() == NULL)
  45     // {
  46     //     return false;
  47     // }
  48
  49     // this is the correct way
  50     const char* a = mDbName.canonicalName();
  51     const char* b = other.mDbName.canonicalName();
  52
  53     if (a == NULL && b != NULL)
  54     {
  55         return true; // NULL is always < something
  56     }
  57
  58     if (a != NULL && b == NULL)
  59     {
  60         return false; // something is always >= NULL
  61     }
  62
  63     if (a == NULL && b == NULL)
  64     {
  65         return false; // since == is not <
  66     }
  67
  68     // if we get to this point, both are not null.  No crash and the lexical value is correct.
  69     return strcmp(a, b) < 0;
  70 }
  71
  72 bool DLDbIdentifier::Impl::operator == (const Impl &other) const
  73 {
  74     bool subserviceIdEqual = mCssmSubserviceUid == other.mCssmSubserviceUid;
  75     if (!subserviceIdEqual)
  76     {
  77         return false;
  78     }
  79
  80     const char* a = mDbName.canonicalName();
  81     const char* b = other.mDbName.canonicalName();
  82
  83     if (a == NULL && b != NULL)
  84     {
  85         return false;
  86     }
  87
  88     if (a !=  NULL && b == NULL)
  89     {
  90         return false;
  91     }
  92
  93     if (a == NULL && b == NULL)
  94     {
  95         return true;
  96     }
  97
  98     bool namesEqual = strcmp(a, b) == 0;
  99     return namesEqual;
 100 }
 101
 102 //
 103 // CssmDLPolyData
 104 //
 105 CssmDLPolyData::operator CSSM_DATE () const
 106 {
 107         assert(mFormat == CSSM_DB_ATTRIBUTE_FORMAT_BLOB);
 108         if (mData.Length != 8)
 109                 CssmError::throwMe(CSSMERR_DL_DATABASE_CORRUPT);
 110
 111         CSSM_DATE date;
 112         memcpy(date.Year, mData.Data, 4);
 113         memcpy(date.Month, mData.Data + 4, 2);
 114         memcpy(date.Day, mData.Data + 6, 2);
 115         return date;
 116 }
 117
 118 CssmDLPolyData::operator Guid () const
 119 {
 120         assert(mFormat == CSSM_DB_ATTRIBUTE_FORMAT_BLOB);
 121         if (mData.Length != Guid::stringRepLength + 1)
 122                 CssmError::throwMe(CSSMERR_DL_DATABASE_CORRUPT);
 123
 124         return Guid(reinterpret_cast<const char *>(mData.Data));
 125 }
 126
 127
 128 //
 129 // CssmDbAttributeInfo
 130 //
 131 CssmDbAttributeInfo::CssmDbAttributeInfo(const char *name, CSSM_DB_ATTRIBUTE_FORMAT vFormat)
 132 {
 133         clearPod();
 134         AttributeNameFormat = CSSM_DB_ATTRIBUTE_NAME_AS_STRING;
 135         Label.AttributeName = const_cast<char *>(name); // silly CDSA
 136         AttributeFormat = vFormat;
 137 }
 138
 139 CssmDbAttributeInfo::CssmDbAttributeInfo(const CSSM_OID &oid, CSSM_DB_ATTRIBUTE_FORMAT vFormat)
 140 {
 141         clearPod();
 142         AttributeNameFormat = CSSM_DB_ATTRIBUTE_NAME_AS_OID;
 143         Label.AttributeOID = oid;
 144         AttributeFormat = vFormat;
 145 }
 146
 147 CssmDbAttributeInfo::CssmDbAttributeInfo(uint32 id, CSSM_DB_ATTRIBUTE_FORMAT vFormat)
 148 {
 149         clearPod();
 150         AttributeNameFormat = CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER;
 151         Label.AttributeID = id;
 152         AttributeFormat = vFormat;
 153 }
 154
 155
 156 bool
 157 CssmDbAttributeInfo::operator <(const CssmDbAttributeInfo& other) const
 158 {
 159         if (nameFormat() < other.nameFormat()) return true;
 160         if (other.nameFormat() < nameFormat()) return false;
 161         // nameFormat's are equal.
 162         switch (nameFormat())
 163         {
 164         case CSSM_DB_ATTRIBUTE_NAME_AS_STRING:
 165         {
 166                 int res = strcmp(static_cast<const char *>(*this), static_cast<const char *>(other));
 167                 if (res < 0) return true;
 168                 if (res > 0) return false;
 169                 break;
 170         }
 171         case CSSM_DB_ATTRIBUTE_NAME_AS_OID:
 172                 if (static_cast<const CssmOid &>(*this) < static_cast<const CssmOid &>(other)) return true;
 173                 if (static_cast<const CssmOid &>(other) < static_cast<const CssmOid &>(*this)) return false;
 174                 break;
 175         case CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER:
 176                 if (static_cast<uint32>(*this) < static_cast<uint32>(other)) return true;
 177                 if (static_cast<uint32>(other) < static_cast<uint32>(*this)) return false;
 178                 break;
 179         default:
 180                 CssmError::throwMe(CSSMERR_DL_INVALID_FIELD_NAME);
 181         }
 182
 183         return format() < other.format();
 184 }
 185
 186 bool
 187 CssmDbAttributeInfo::operator ==(const CssmDbAttributeInfo& other) const
 188 {
 189         if (nameFormat() != other.nameFormat()) return false;
 190         if (format() != other.format()) return false;
 191         switch (nameFormat())
 192         {
 193         case CSSM_DB_ATTRIBUTE_NAME_AS_STRING:
 194                 return !strcmp(static_cast<const char *>(*this), static_cast<const char *>(other));
 195         case CSSM_DB_ATTRIBUTE_NAME_AS_OID:
 196                 return static_cast<const CssmOid &>(*this) == static_cast<const CssmOid &>(other);
 197         case CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER:
 198                 return static_cast<uint32>(*this) == static_cast<uint32>(other);
 199         default:
 200                 CssmError::throwMe(CSSMERR_DL_INVALID_FIELD_NAME);
 201         }
 202 }
 203
 204 //
 205 // CssmDbAttributeData
 206 //
 207 CssmDbAttributeData::operator string() const
 208 {
 209         switch (format()) {
 210         case CSSM_DB_ATTRIBUTE_FORMAT_STRING:
 211         case CSSM_DB_ATTRIBUTE_FORMAT_BLOB:
 212                 return at(0).toString();
 213         default:
 214                 CssmError::throwMe(CSSMERR_DL_INCOMPATIBLE_FIELD_FORMAT);
 215         }
 216 }
 217 CssmDbAttributeData::operator const Guid &() const
 218 {
 219         if (format() == CSSM_DB_ATTRIBUTE_FORMAT_BLOB)
 220                 return *at(0).interpretedAs<Guid>();
 221         else
 222                 CssmError::throwMe(CSSMERR_DL_INCOMPATIBLE_FIELD_FORMAT);
 223 }
 224
 225 CssmDbAttributeData::operator bool() const
 226 {
 227         switch (format()) {
 228         case CSSM_DB_ATTRIBUTE_FORMAT_UINT32:
 229         case CSSM_DB_ATTRIBUTE_FORMAT_SINT32:
 230                 return *at(0).interpretedAs<uint32>();
 231         default:
 232                 CssmError::throwMe(CSSMERR_DL_INCOMPATIBLE_FIELD_FORMAT);
 233         }
 234 }
 235
 236 CssmDbAttributeData::operator uint32() const
 237 {
 238         if (format() == CSSM_DB_ATTRIBUTE_FORMAT_UINT32)
 239                 return *at(0).interpretedAs<uint32>();
 240         else
 241                 CssmError::throwMe(CSSMERR_DL_INCOMPATIBLE_FIELD_FORMAT);
 242 }
 243
 244 CssmDbAttributeData::operator const uint32 *() const
 245 {
 246         if (format() == CSSM_DB_ATTRIBUTE_FORMAT_MULTI_UINT32)
 247                 return reinterpret_cast<const uint32 *>(Value[0].Data);
 248         else
 249                 CssmError::throwMe(CSSMERR_DL_INCOMPATIBLE_FIELD_FORMAT);
 250 }
 251
 252 CssmDbAttributeData::operator sint32() const
 253 {
 254         if (format() == CSSM_DB_ATTRIBUTE_FORMAT_SINT32)
 255                 return *at(0).interpretedAs<sint32>();
 256         else
 257                 CssmError::throwMe(CSSMERR_DL_INCOMPATIBLE_FIELD_FORMAT);
 258 }
 259
 260 CssmDbAttributeData::operator double() const
 261 {
 262         if (format() == CSSM_DB_ATTRIBUTE_FORMAT_REAL)
 263                 return *at(0).interpretedAs<double>();
 264         else
 265                 CssmError::throwMe(CSSMERR_DL_INCOMPATIBLE_FIELD_FORMAT);
 266 }
 267
 268 CssmDbAttributeData::operator const CssmData &() const
 269 {
 270         switch (format()) {
 271         case CSSM_DB_ATTRIBUTE_FORMAT_STRING:
 272         case CSSM_DB_ATTRIBUTE_FORMAT_BIG_NUM:
 273         case CSSM_DB_ATTRIBUTE_FORMAT_TIME_DATE:
 274         case CSSM_DB_ATTRIBUTE_FORMAT_BLOB:
 275         case CSSM_DB_ATTRIBUTE_FORMAT_MULTI_UINT32:
 276                 return at(0);
 277         default:
 278                 CssmError::throwMe(CSSMERR_DL_INCOMPATIBLE_FIELD_FORMAT);
 279         }
 280 }
 281
 282 void CssmDbAttributeData::set(const CSSM_DB_ATTRIBUTE_INFO &inInfo, const CssmPolyData &inValue,
 283                  Allocator &inAllocator)
 284 {
 285         info(inInfo);
 286         NumberOfValues = 0;
 287         Value = inAllocator.alloc<CSSM_DATA>();
 288         Value[0].Length = 0;
 289         Value[0].Data = inAllocator.alloc<uint8>((UInt32)inValue.Length);
 290         Value[0].Length = inValue.Length;
 291         memcpy(Value[0].Data, inValue.Data, inValue.Length);
 292         NumberOfValues = 1;
 293 }
 294
 295 void CssmDbAttributeData::add(const CssmPolyData &inValue, Allocator &inAllocator)
 296 {
 297         Value = reinterpret_cast<CSSM_DATA *>(inAllocator.realloc(Value, sizeof(*Value) * (NumberOfValues + 1)));
 298         CssmAutoData valueCopy(inAllocator, inValue);
 299         Value[NumberOfValues++] = valueCopy.release();
 300 }
 301
 302
 303 void CssmDbAttributeData::copyValues(const CssmDbAttributeData &source, Allocator &alloc)
 304 {
 305         assert(size() == 0);    // must start out empty
 306
 307         // we're too lazy to arrange for exception safety here
 308         CssmData *vector = alloc.alloc<CssmData>(source.size());
 309         for (uint32 n = 0; n < source.size(); n++)
 310                 vector[n] = CssmAutoData(alloc, source[n]).release();
 311
 312         // atomic set results
 313         info().format(source.info().format());
 314         NumberOfValues = source.size();
 315         values() = vector;
 316 }
 317
 318 void CssmDbAttributeData::deleteValues(Allocator &alloc)
 319 {
 320         // Loop over all values and delete each one.
 321         if (values())
 322         {
 323                 for (uint32 n = 0; n < size(); n++)
 324                 {
 325                         alloc.free(at(n).data());
 326                 }
 327                 alloc.free(values());
 328         }
 329         NumberOfValues = 0;
 330         values() = NULL;
 331 }
 332
 333 bool CssmDbAttributeData::operator <(const CssmDbAttributeData &other) const
 334 {
 335         if (info() < other.info()) return true;
 336         if (other.info() < info()) return false;
 337
 338         uint32 minSize = min(size(), other.size());
 339         for (uint32 ix = 0; ix < minSize; ++ix)
 340         {
 341                 if (at<const CssmData &>(ix) < other.at<const CssmData &>(ix))
 342                         return true;
 343                 if (other.at<const CssmData &>(ix) < at<const CssmData &>(ix))
 344                         return false;
 345         }
 346
 347         return size() < other.size();
 348 }
 349
 350 void
 351 CssmDbAttributeData::add(const CssmDbAttributeData &src, Allocator &inAllocator)
 352 {
 353         // Add all the values from another attribute into this attribute.
 354
 355         Value = reinterpret_cast<CSSM_DATA *>(inAllocator.realloc(Value,
 356                 sizeof(*Value) * (NumberOfValues + src.NumberOfValues)));
 357
 358         for (uint32 srcIndex = 0; srcIndex < src.NumberOfValues; srcIndex++) {
 359                 uint32 destIndex = NumberOfValues + srcIndex;
 360
 361                 Value[destIndex].Length = 0;
 362                 Value[destIndex].Data = inAllocator.alloc<uint8>((UInt32)src.Value[srcIndex].Length);
 363                 Value[destIndex].Length = src.Value[srcIndex].Length;
 364                 memcpy(Value[destIndex].Data, src.Value[srcIndex].Data, src.Value[srcIndex].Length);
 365         }
 366
 367         NumberOfValues += src.NumberOfValues;
 368 }
 369
 370 bool
 371 CssmDbAttributeData::deleteValue(const CssmData &src, Allocator &inAllocator)
 372 {
 373         // Delete a single value from this attribute, if it is present.
 374
 375         for (uint32 i = 0; i < NumberOfValues; i++)
 376                 if (CssmData::overlay(Value[i]) == src)
 377                 {
 378                         inAllocator.free(Value[i].Data);
 379                         Value[i].Length = 0;
 380
 381                         NumberOfValues--;
 382                         Value[i].Data = Value[NumberOfValues].Data;
 383                         Value[i].Length = Value[NumberOfValues].Length;
 384
 385                         return true;
 386                 }
 387
 388         return false;
 389 }
 390
 391 // Delete those values found in src from this object, if they are present.
 392 // Warning: This is O(N^2) worst case; if this becomes a performance bottleneck
 393 // then it will need to be changed.
 394
 395 void
 396 CssmDbAttributeData::deleteValues(const CssmDbAttributeData &src, Allocator &inAllocator)
 397 {
 398         for (uint32 i = 0; i < src.NumberOfValues; i++)
 399                 deleteValue(CssmData::overlay(src.Value[i]), inAllocator);
 400 }
 401
 402 //
 403 // CssmDbRecordAttributeData
 404 //
 405 CssmDbAttributeData *
 406 CssmDbRecordAttributeData::find(const CSSM_DB_ATTRIBUTE_INFO &inInfo)
 407 {
 408         const CssmDbAttributeInfo &anInfo = CssmDbAttributeInfo::overlay(inInfo);
 409         for (uint32 ix = 0; ix < size(); ++ix)
 410         {
 411                 if (at(ix).info() == anInfo)
 412                         return &at(ix);
 413         }
 414
 415         return NULL;
 416 }
 417
 418 bool
 419 CssmDbRecordAttributeData::operator <(const CssmDbRecordAttributeData &other) const
 420 {
 421         if (recordType() < other.recordType()) return true;
 422         if (other.recordType() < recordType()) return false;
 423         if (semanticInformation() < other.semanticInformation()) return true;
 424         if (other.semanticInformation() < semanticInformation()) return false;
 425
 426         uint32 minSize = min(size(), other.size());
 427         for (uint32 ix = 0; ix < minSize; ++ix)
 428         {
 429                 if (at(ix) < other.at(ix))
 430                         return true;
 431                 if (other.at(ix) < at(ix))
 432                         return false;
 433         }
 434
 435         return size() < other.size();
 436 }
 437
 438
 439 //
 440 // CssmAutoDbRecordAttributeData
 441 //
 442 CssmAutoDbRecordAttributeData::~CssmAutoDbRecordAttributeData()
 443 {
 444         clear();
 445 }
 446
 447 void
 448 CssmAutoDbRecordAttributeData::invalidate()
 449 {
 450         NumberOfAttributes = 0;
 451 }
 452
 453
 454
 455 void
 456 CssmAutoDbRecordAttributeData::clear()
 457 {
 458         deleteValues();
 459         ArrayBuilder<CssmDbAttributeData>::clear();
 460 }
 461
 462
 463
 464 static bool CompareAttributeInfos (const CSSM_DB_ATTRIBUTE_INFO &a, const CSSM_DB_ATTRIBUTE_INFO &b)
 465 {
 466         // check the format of the names
 467         if (a.AttributeNameFormat != b.AttributeNameFormat)
 468         {
 469                 return false;
 470         }
 471
 472         switch (a.AttributeNameFormat)
 473         {
 474                 case CSSM_DB_ATTRIBUTE_NAME_AS_STRING:
 475                 {
 476                         return strcmp (a.Label.AttributeName, b.Label.AttributeName) == 0;
 477                 }
 478
 479                 case CSSM_DB_ATTRIBUTE_NAME_AS_OID:
 480                 {
 481                         if (a.Label.AttributeOID.Length != b.Label.AttributeOID.Length)
 482                         {
 483                                 return false;
 484                         }
 485
 486                         return memcmp (a.Label.AttributeOID.Data, b.Label.AttributeOID.Data, a.Label.AttributeOID.Length) == 0;
 487                 }
 488
 489
 490                 case CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER:
 491                 {
 492                         return a.Label.AttributeID == b.Label.AttributeID;
 493                 }
 494         }
 495
 496         return true; // just to keep the compiler from complaining
 497 }
 498
 499
 500
 501 CssmDbAttributeData* CssmAutoDbRecordAttributeData::findAttribute (const CSSM_DB_ATTRIBUTE_INFO &info)
 502 {
 503         // walk through the data, looking for an attribute of the same type
 504         unsigned i;
 505         for (i = 0; i < size (); ++i)
 506         {
 507                 CssmDbAttributeData& d = at (i);
 508                 CSSM_DB_ATTRIBUTE_INFO &inInfo = d.info ();
 509
 510                 if (CompareAttributeInfos (info, inInfo))
 511                 {
 512                         return &d;
 513                 }
 514         }
 515
 516         // found nothing?
 517         return NULL;
 518 }
 519
 520
 521
 522 CssmDbAttributeData& CssmAutoDbRecordAttributeData::getAttributeReference (const CSSM_DB_ATTRIBUTE_INFO &info)
 523 {
 524         // Either find an existing reference to an attribute in the list, or make a new one.
 525         CssmDbAttributeData *anAttr = findAttribute (info);
 526         if (anAttr) // was this already in the list?
 527         {
 528                 // clean it up
 529                 anAttr->deleteValues (mValueAllocator);
 530         }
 531         else
 532         {
 533                 // make a new one
 534                 anAttr = &add();
 535         }
 536
 537         return *anAttr;
 538 }
 539
 540
 541
 542 CssmDbAttributeData &
 543 CssmAutoDbRecordAttributeData::add(const CSSM_DB_ATTRIBUTE_INFO &info)
 544 {
 545         CssmDbAttributeData& anAttr = getAttributeReference (info);
 546         anAttr.info(info);
 547         return anAttr;
 548 }
 549
 550 CssmDbAttributeData &
 551 CssmAutoDbRecordAttributeData::add(const CSSM_DB_ATTRIBUTE_INFO &info, const CssmPolyData &value)
 552 {
 553         CssmDbAttributeData &anAttr = getAttributeReference (info);
 554         anAttr.set(info, value, mValueAllocator);
 555         return anAttr;
 556 }
 557
 558 void
 559 CssmAutoDbRecordAttributeData::updateWith(const CssmAutoDbRecordAttributeData* newValues) {
 560     if(!newValues) {
 561         return;
 562     }
 563     for(int i = 0; i < newValues->size(); i++) {
 564         CssmDbAttributeData& c = newValues->at(i);
 565         CssmDbAttributeData& target = add(c.info());
 566
 567         target.info(c.info());
 568         target.copyValues(c, mValueAllocator);
 569             //.set(c, mValueAllocator);
 570     }
 571 }
 572
 573 //
 574 // CssmAutoQuery
 575 //
 576 CssmAutoQuery::CssmAutoQuery(const CSSM_QUERY &query, Allocator &allocator)
 577 : ArrayBuilder<CssmSelectionPredicate>(CssmSelectionPredicate::overlayVar(SelectionPredicate),
 578                                                                            NumSelectionPredicates,
 579                                                                            query.NumSelectionPredicates, allocator)
 580 {
 581         RecordType = query.RecordType;
 582         Conjunctive = query.Conjunctive;
 583         QueryLimits =  query.QueryLimits;
 584         QueryFlags = query.QueryFlags;
 585         for (uint32 ix = 0; ix < query.NumSelectionPredicates; ++ix)
 586                 add().set(query.SelectionPredicate[ix], allocator);
 587 }
 588
 589 CssmAutoQuery::~CssmAutoQuery()
 590 {
 591         clear();
 592 }
 593
 594 void
 595 CssmAutoQuery::clear()
 596 {
 597         deleteValues();
 598         ArrayBuilder<CssmSelectionPredicate>::clear();
 599 }
 600
 601 CssmSelectionPredicate &
 602 CssmAutoQuery::add(CSSM_DB_OPERATOR dbOperator, const CSSM_DB_ATTRIBUTE_INFO &info, const CssmPolyData &value)
 603 {
 604         CssmSelectionPredicate &predicate = add();
 605         predicate.dbOperator(dbOperator);
 606         predicate.set(info, value, allocator());
 607         return predicate;
 608 }