ntoskrnl/ex/uuid.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS kernel
   4  * FILE:            ntoskrnl/ex/uuid.c
   5  * PURPOSE:         UUID generator
   6  * PROGRAMMERS:     Eric Kohl
   7  *                  Thomas Weidenmueller
   8  *                  Pierre Schweitzer
   9  */
  10
  11 /* INCLUDES *****************************************************************/
  12
  13 #include <ntoskrnl.h>
  14 #define NDEBUG
  15 #include <debug.h>
  16
  17 #define SEED_BUFFER_SIZE 6
  18
  19 /* Number of 100ns ticks per clock tick. To be safe, assume that the clock
  20    resolution is at least 1000 * 100 * (1/1000000) = 1/10 of a second */
  21 #define TICKS_PER_CLOCK_TICK 1000
  22 #define SECSPERDAY  86400
  23 #define TICKSPERSEC 10000000
  24
  25 /* UUID system time starts at October 15, 1582 */
  26 #define SECS_15_OCT_1582_TO_1601  ((17 + 30 + 31 + 365 * 18 + 5) * SECSPERDAY)
  27 #define TICKS_15_OCT_1582_TO_1601 ((ULONGLONG)SECS_15_OCT_1582_TO_1601 * TICKSPERSEC)
  28
  29 /* 10000 in 100-ns model = 0,1 microsecond */
  30 #define TIME_FRAME 10000
  31
  32 #if defined (ALLOC_PRAGMA)
  33 #pragma alloc_text(INIT, ExpUuidInitialization)
  34 #pragma alloc_text(INIT, ExLuidInitialization)
  35 #endif
  36
  37
  38 /* GLOBALS ****************************************************************/
  39
  40 FAST_MUTEX ExpUuidLock;
  41 LARGE_INTEGER ExpUuidLastTimeAllocated;
  42 ULONG ExpUuidSequenceNumber = 0;
  43 BOOLEAN ExpUuidSequenceNumberValid;
  44 BOOLEAN ExpUuidSequenceNumberNotSaved = FALSE;
  45 UUID_CACHED_VALUES_STRUCT ExpUuidCachedValues = {0ULL, 0xFFFFFFFF, 0, 0, { 0x80, 0x6E, 0x6F, 0x6E, 0x69, 0x63}};
  46 BOOLEAN ExpUuidCacheValid = FALSE;
  47 ULONG ExpLuidIncrement = 1;
  48 LARGE_INTEGER ExpLuid = {.LowPart = 0x3e9, .HighPart = 0x0};
  49
  50 /* FUNCTIONS ****************************************************************/
  51
  52 /*
  53  * @implemented
  54  */
  55 BOOLEAN
  56 INIT_FUNCTION
  57 NTAPI
  58 ExpUuidInitialization(VOID)
  59 {
  60     ExInitializeFastMutex(&ExpUuidLock);
  61
  62     ExpUuidSequenceNumberValid = FALSE;
  63     KeQuerySystemTime(&ExpUuidLastTimeAllocated);
  64
  65     return TRUE;
  66 }
  67
  68
  69 /*
  70  * @implemented
  71  */
  72 #define VALUE_BUFFER_SIZE 20
  73 static NTSTATUS
  74 ExpUuidLoadSequenceNumber(PULONG Sequence)
  75 {
  76     UCHAR ValueBuffer[VALUE_BUFFER_SIZE];
  77     PKEY_VALUE_PARTIAL_INFORMATION ValueInfo;
  78     OBJECT_ATTRIBUTES ObjectAttributes;
  79     UNICODE_STRING KeyName, ValueName;
  80     HANDLE KeyHandle;
  81     ULONG ValueLength;
  82     NTSTATUS Status;
  83
  84     PAGED_CODE();
  85
  86     RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\Software\\Microsoft\\Rpc");
  87     RtlInitUnicodeString(&ValueName, L"UuidSequenceNumber");
  88
  89     InitializeObjectAttributes(&ObjectAttributes,
  90                                &KeyName,
  91                                OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
  92                                NULL,
  93                                NULL);
  94     Status = ZwOpenKey(&KeyHandle, GENERIC_READ, &ObjectAttributes);
  95     if (!NT_SUCCESS(Status))
  96     {
  97         DPRINT("ZwOpenKey() failed (Status %lx)\n", Status);
  98         return Status;
  99     }
 100
 101     ValueInfo = (PKEY_VALUE_PARTIAL_INFORMATION)ValueBuffer;
 102     Status = ZwQueryValueKey(KeyHandle,
 103                              &ValueName,
 104                              KeyValuePartialInformation,
 105                              ValueBuffer,
 106                              VALUE_BUFFER_SIZE,
 107                              &ValueLength);
 108     ZwClose(KeyHandle);
 109     if (!NT_SUCCESS(Status))
 110     {
 111         DPRINT("ZwQueryValueKey() failed (Status %lx)\n", Status);
 112         return Status;
 113     }
 114
 115     if (ValueInfo->Type != REG_DWORD || ValueInfo->DataLength != sizeof(DWORD))
 116     {
 117         return STATUS_UNSUCCESSFUL;
 118     }
 119
 120     *Sequence = *((PULONG)ValueInfo->Data);
 121
 122     DPRINT("Loaded sequence %lx\n", *Sequence);
 123
 124     return STATUS_SUCCESS;
 125 }
 126 #undef VALUE_BUFFER_SIZE
 127
 128 /*
 129  * @implemented
 130  */
 131 static NTSTATUS
 132 ExpUuidSaveSequenceNumber(PULONG Sequence)
 133 {
 134     OBJECT_ATTRIBUTES ObjectAttributes;
 135     UNICODE_STRING KeyName, ValueName;
 136     HANDLE KeyHandle;
 137     NTSTATUS Status;
 138
 139     PAGED_CODE();
 140
 141     RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\Software\\Microsoft\\Rpc");
 142     RtlInitUnicodeString(&ValueName, L"UuidSequenceNumber");
 143
 144     InitializeObjectAttributes(&ObjectAttributes,
 145                                &KeyName,
 146                                OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
 147                                NULL,
 148                                NULL);
 149     Status = ZwOpenKey(&KeyHandle,
 150                        GENERIC_READ | GENERIC_WRITE,
 151                        &ObjectAttributes);
 152     if (!NT_SUCCESS(Status))
 153     {
 154         DPRINT("ZwOpenKey() failed (Status %lx)\n", Status);
 155         return Status;
 156     }
 157
 158     Status = ZwSetValueKey(KeyHandle,
 159                            &ValueName,
 160                            0,
 161                            REG_DWORD,
 162                            Sequence,
 163                            sizeof(ULONG));
 164     ZwClose(KeyHandle);
 165     if (!NT_SUCCESS(Status))
 166     {
 167         DPRINT("ZwSetValueKey() failed (Status %lx)\n", Status);
 168     }
 169
 170     return Status;
 171 }
 172
 173 /*
 174  * @implemented
 175  * Warning! This function must be called
 176  * with ExpUuidLock held!
 177  */
 178 static VOID
 179 ExpUuidSaveSequenceNumberIf(VOID)
 180 {
 181     NTSTATUS Status;
 182
 183     PAGED_CODE();
 184
 185     /* Only save sequence if it has to */
 186     if (ExpUuidSequenceNumberNotSaved == TRUE)
 187     {
 188         Status = ExpUuidSaveSequenceNumber(&ExpUuidSequenceNumber);
 189         if (NT_SUCCESS(Status))
 190         {
 191             ExpUuidSequenceNumberNotSaved = FALSE;
 192         }
 193     }
 194 }
 195
 196 /*
 197  * @implemented
 198  * Warning! This function must be called
 199  * with ExpUuidLock held!
 200  */
 201 static NTSTATUS
 202 ExpAllocateUuids(PULARGE_INTEGER Time,
 203                  PULONG Range,
 204                  PULONG Sequence)
 205 {
 206     NTSTATUS Status;
 207     LARGE_INTEGER Counter, Frequency, CurrentTime, TimeDiff, ClockDiff;
 208
 209     PAGED_CODE();
 210
 211     /* Initialize sequence number */
 212     if (!ExpUuidSequenceNumberValid)
 213     {
 214         /* Try to load sequence number */
 215         Status = ExpUuidLoadSequenceNumber(&ExpUuidSequenceNumber);
 216         if (NT_SUCCESS(Status))
 217         {
 218             ++ExpUuidSequenceNumber;
 219         }
 220         else
 221         {
 222             /* If we cannot, generate a "true" random */
 223             Counter = KeQueryPerformanceCounter(&Frequency);
 224             ExpUuidSequenceNumber ^= (ULONG_PTR)&Status ^ (ULONG_PTR)Sequence ^ Counter.LowPart ^ Counter.HighPart;
 225         }
 226
 227         /* It's valid and to be saved */
 228         ExpUuidSequenceNumberValid = TRUE;
 229         ExpUuidSequenceNumberNotSaved = TRUE;
 230     }
 231
 232     KeQuerySystemTime(&CurrentTime);
 233     TimeDiff.QuadPart = CurrentTime.QuadPart - ExpUuidLastTimeAllocated.QuadPart;
 234     /* If time went backwards, change sequence (see RFC example) */
 235     if (TimeDiff.QuadPart < 0)
 236     {
 237         ++ExpUuidSequenceNumber;
 238         TimeDiff.QuadPart = 2 * TIME_FRAME;
 239
 240         /* It's to be saved */
 241         ExpUuidSequenceNumberNotSaved = TRUE;
 242         ExpUuidLastTimeAllocated.QuadPart = CurrentTime.QuadPart - 2 * TIME_FRAME;
 243     }
 244
 245     if (TimeDiff.QuadPart == 0)
 246     {
 247         return STATUS_RETRY;
 248     }
 249
 250     /* If time diff > 0,1ms, squash it to reduce it to keep our clock resolution */
 251     if (TimeDiff.HighPart > 0 || TimeDiff.QuadPart > TICKS_PER_CLOCK_TICK * TIME_FRAME)
 252     {
 253         TimeDiff.QuadPart = TICKS_PER_CLOCK_TICK * TIME_FRAME;
 254     }
 255
 256     if (TimeDiff.HighPart < 0 || TimeDiff.QuadPart <= TIME_FRAME)
 257     {
 258         *Range = TimeDiff.QuadPart;
 259         ClockDiff.QuadPart = 0LL;
 260     }
 261     else
 262     {
 263         *Range = TIME_FRAME;
 264         ClockDiff.QuadPart = TimeDiff.QuadPart - TIME_FRAME;
 265         --ClockDiff.HighPart;
 266     }
 267
 268     Time->QuadPart = CurrentTime.QuadPart - *Range - ClockDiff.QuadPart;
 269     ExpUuidLastTimeAllocated.QuadPart = CurrentTime.QuadPart - ClockDiff.QuadPart;
 270     *Sequence = ExpUuidSequenceNumber;
 271
 272     return STATUS_SUCCESS;
 273 }
 274
 275 /*
 276  * @implemented
 277  * Warning! This function must be called
 278  * with ExpUuidLock held!
 279  */
 280 static NTSTATUS
 281 ExpUuidGetValues(PUUID_CACHED_VALUES_STRUCT CachedValues)
 282 {
 283     NTSTATUS Status;
 284     ULARGE_INTEGER Time;
 285     ULONG Range;
 286     ULONG Sequence;
 287
 288     PAGED_CODE();
 289
 290     /* Allocate UUIDs */
 291     Status = ExpAllocateUuids(&Time, &Range, &Sequence);
 292     if (Status == STATUS_RETRY)
 293     {
 294         return Status;
 295     }
 296
 297     if (!NT_SUCCESS(Status))
 298     {
 299         return STATUS_NO_MEMORY;
 300     }
 301
 302     /* We need at least one UUID */
 303     ASSERT(Range != 0);
 304
 305     /* Set up our internal cache
 306      * See format_uuid_v1 in RFC4122 for magic values
 307      */
 308     CachedValues->ClockSeqLow = Sequence;
 309     CachedValues->ClockSeqHiAndReserved = (Sequence & 0x3F00) >> 8;
 310     CachedValues->ClockSeqHiAndReserved |= 0x80;
 311     CachedValues->AllocatedCount = Range;
 312
 313     /*
 314      * Time is relative to UUID time
 315      * And we set last time range for all the possibly
 316      * returnable UUID
 317      */
 318     Time.QuadPart += TICKS_15_OCT_1582_TO_1601;
 319     CachedValues->Time = Time.QuadPart + (Range - 1);
 320
 321     return STATUS_SUCCESS;
 322 }
 323
 324 /*
 325  * @implemented
 326  */
 327 BOOLEAN
 328 INIT_FUNCTION
 329 NTAPI
 330 ExLuidInitialization(VOID)
 331 {
 332     return TRUE;
 333 }
 334
 335 /*
 336  * @implemented
 337  */
 338 VOID
 339 NTAPI
 340 ExAllocateLocallyUniqueId(OUT LUID *LocallyUniqueId)
 341 {
 342     LARGE_INTEGER PrevLuid;
 343     LONGLONG NewLuid, CompLuid;
 344
 345     /* Atomically increment the luid */
 346     PrevLuid.QuadPart = ExpLuid.QuadPart;
 347     for (NewLuid = ExpLuid.QuadPart + ExpLuidIncrement; ;
 348          NewLuid = PrevLuid.QuadPart + ExpLuidIncrement)
 349     {
 350         CompLuid = InterlockedCompareExchange64(&ExpLuid.QuadPart,
 351                                                 NewLuid,
 352                                                 PrevLuid.QuadPart);
 353         if (CompLuid == PrevLuid.QuadPart)
 354         {
 355             break;
 356         }
 357
 358         PrevLuid.QuadPart = CompLuid;
 359     }
 360
 361     LocallyUniqueId->LowPart = PrevLuid.LowPart;
 362     LocallyUniqueId->HighPart = PrevLuid.HighPart;
 363 }
 364
 365
 366 /*
 367  * @implemented
 368  */
 369 NTSTATUS
 370 NTAPI
 371 NtAllocateLocallyUniqueId(OUT LUID *LocallyUniqueId)
 372 {
 373     KPROCESSOR_MODE PreviousMode;
 374     PAGED_CODE();
 375
 376     /* Probe if user mode */
 377     PreviousMode = ExGetPreviousMode();
 378     if (PreviousMode != KernelMode)
 379     {
 380         _SEH2_TRY
 381         {
 382             ProbeForWrite(LocallyUniqueId,
 383                           sizeof(LUID),
 384                           sizeof(ULONG));
 385         }
 386         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 387         {
 388             _SEH2_YIELD(return _SEH2_GetExceptionCode());
 389         }
 390         _SEH2_END;
 391     }
 392
 393     /* Do the allocation */
 394     ExAllocateLocallyUniqueId(LocallyUniqueId);
 395     return STATUS_SUCCESS;
 396 }
 397
 398 /*
 399  * @implemented
 400  */
 401 NTSTATUS
 402 NTAPI
 403 ExUuidCreate(OUT UUID *Uuid)
 404 {
 405     NTSTATUS Status;
 406     LONG AllocatedCount;
 407     LARGE_INTEGER Time;
 408     BOOLEAN Valid;
 409
 410     PAGED_CODE();
 411
 412     Status = STATUS_SUCCESS;
 413     /* Loop until we have an UUID to return */
 414     while (TRUE)
 415     {
 416         /* Try to gather node values */
 417         do
 418         {
 419             Time.QuadPart = ExpUuidCachedValues.Time;
 420
 421             RtlCopyMemory(&Uuid->Data4[0],
 422                           &ExpUuidCachedValues.NodeId[0],
 423                           SEED_BUFFER_SIZE);
 424             Valid = ExpUuidCacheValid;
 425             AllocatedCount = InterlockedDecrement(&ExpUuidCachedValues.AllocatedCount);
 426         }
 427         /* Loop till we can do it without being disturbed */
 428         while (Time.QuadPart != ExpUuidCachedValues.Time);
 429
 430         /* We have more than an allocated UUID left, that's OK to return! */
 431         if (AllocatedCount >= 0)
 432         {
 433             break;
 434         }
 435
 436         /*
 437          * Here, we're out of UUIDs, we need to allocate more
 438          * We need to be alone to do it, so lock the mutex
 439          */
 440         ExAcquireFastMutex(&ExpUuidLock);
 441         if (Time.QuadPart == ExpUuidCachedValues.Time)
 442         {
 443             /* If allocation fails, bail out! */
 444             Status = ExpUuidGetValues(&ExpUuidCachedValues);
 445             if (Status != STATUS_SUCCESS)
 446             {
 447                 ExReleaseFastMutex(&ExpUuidLock);
 448                 return Status;
 449             }
 450
 451             /* Save our current sequence if changed */
 452             ExpUuidSaveSequenceNumberIf();
 453         }
 454         ExReleaseFastMutex(&ExpUuidLock);
 455     }
 456
 457     /*
 458      * Once here, we've got an UUID to return
 459      * But, if our init wasn't sane, then, make
 460      * sure it's only used locally
 461      */
 462     if (!Valid)
 463     {
 464         Status = RPC_NT_UUID_LOCAL_ONLY;
 465     }
 466
 467     /* Set our timestamp - see RFC4211 */
 468     Time.QuadPart -= AllocatedCount;
 469     Uuid->Data1 = Time.LowPart;
 470     Uuid->Data2 = Time.HighPart;
 471     /* We also set the bit for GUIDv1 */
 472     Uuid->Data3 = ((Time.HighPart >> 16) & 0x0FFF) | 0x1000;
 473
 474     return Status;
 475 }
 476
 477 /*
 478  * @implemented
 479  */
 480 NTSTATUS
 481 NTAPI
 482 NtAllocateUuids(OUT PULARGE_INTEGER Time,
 483                 OUT PULONG Range,
 484                 OUT PULONG Sequence,
 485                 OUT PUCHAR Seed)
 486 {
 487     ULARGE_INTEGER IntTime;
 488     ULONG IntRange, IntSequence;
 489     NTSTATUS Status;
 490     KPROCESSOR_MODE PreviousMode;
 491
 492     PAGED_CODE();
 493
 494     /* Probe if user mode */
 495     PreviousMode = ExGetPreviousMode();
 496     if (PreviousMode != KernelMode)
 497     {
 498         _SEH2_TRY
 499         {
 500             ProbeForWrite(Time,
 501                           sizeof(ULARGE_INTEGER),
 502                           sizeof(ULONG));
 503
 504             ProbeForWrite(Range,
 505                           sizeof(ULONG),
 506                           sizeof(ULONG));
 507
 508             ProbeForWrite(Sequence,
 509                           sizeof(ULONG),
 510                           sizeof(ULONG));
 511
 512             ProbeForWrite(Seed,
 513                           SEED_BUFFER_SIZE,
 514                           sizeof(UCHAR));
 515         }
 516         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 517         {
 518             _SEH2_YIELD(return _SEH2_GetExceptionCode());
 519         }
 520         _SEH2_END;
 521     }
 522
 523     /* During allocation we must be alone */
 524     ExAcquireFastMutex(&ExpUuidLock);
 525
 526     Status = ExpAllocateUuids(&IntTime,
 527                               &IntRange,
 528                               &IntSequence);
 529     if (!NT_SUCCESS(Status))
 530     {
 531         ExReleaseFastMutex(&ExpUuidLock);
 532         return Status;
 533     }
 534
 535     /* If sequence number was changed, save it */
 536     ExpUuidSaveSequenceNumberIf();
 537
 538     /* Allocation done, so we can release */
 539     ExReleaseFastMutex(&ExpUuidLock);
 540
 541     /* Write back UUIDs to caller */
 542     _SEH2_TRY
 543     {
 544         Time->QuadPart = IntTime.QuadPart;
 545         *Range = IntRange;
 546         *Sequence = IntSequence;
 547
 548         RtlCopyMemory(Seed,
 549                       &ExpUuidCachedValues.NodeId[0],
 550                       SEED_BUFFER_SIZE);
 551
 552         Status = STATUS_SUCCESS;
 553     }
 554     _SEH2_EXCEPT(ExSystemExceptionFilter())
 555     {
 556         Status = _SEH2_GetExceptionCode();
 557     }
 558     _SEH2_END;
 559
 560     return Status;
 561 }
 562
 563
 564 /*
 565  * @implemented
 566  */
 567 NTSTATUS
 568 NTAPI
 569 NtSetUuidSeed(IN PUCHAR Seed)
 570 {
 571     NTSTATUS Status;
 572     BOOLEAN GotContext;
 573     PACCESS_TOKEN Token;
 574     SECURITY_SUBJECT_CONTEXT SubjectContext;
 575     LUID CallerLuid, SystemLuid = SYSTEM_LUID;
 576
 577     PAGED_CODE();
 578
 579     /* Should only be done by umode */
 580     ASSERT(KeGetPreviousMode() != KernelMode);
 581
 582     /* No context to release */
 583     GotContext = FALSE;
 584     _SEH2_TRY
 585     {
 586         /* Get our caller context and remember to release it */
 587         SeCaptureSubjectContext(&SubjectContext);
 588         GotContext = TRUE;
 589
 590         /* Get caller access token and its associated ID */
 591         Token = SeQuerySubjectContextToken(&SubjectContext);
 592         Status = SeQueryAuthenticationIdToken(Token, &CallerLuid);
 593         if (!NT_SUCCESS(Status))
 594         {
 595             RtlRaiseStatus(Status);
 596         }
 597
 598         /* This call is only allowed for SYSTEM */
 599         if (!RtlEqualLuid(&CallerLuid, &SystemLuid))
 600         {
 601             RtlRaiseStatus(STATUS_ACCESS_DENIED);
 602         }
 603
 604         /* Check for buffer validity and then copy it to our seed */
 605         ProbeForRead(Seed, SEED_BUFFER_SIZE, sizeof(UCHAR));
 606         RtlCopyMemory(&ExpUuidCachedValues.NodeId[0], Seed, SEED_BUFFER_SIZE);
 607
 608         /*
 609          * According to RFC 4122, UUID seed is based on MAC addresses
 610          * If it is randomly set, then, it must have its multicast be set
 611          * to be valid and avoid collisions
 612          * Reflect it here
 613          */
 614         ExpUuidCacheValid = ~(*Seed >> 7) & 1;
 615
 616         Status = STATUS_SUCCESS;
 617     }
 618     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 619     {
 620         Status = _SEH2_GetExceptionCode();
 621     }
 622     _SEH2_END;
 623
 624     /* Release context if required */
 625     if (GotContext)
 626     {
 627         SeReleaseSubjectContext(&SubjectContext);
 628     }
 629
 630     return Status;
 631 }
 632
 633 /* EOF */