granicus.if.org Git - imagemagick/blob - MagickCore/random.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                 RRRR    AAA   N   N  DDDD    OOO   M   M                    %
   6 %                 R   R  A   A  NN  N  D   D  O   O  MM MM                    %
   7 %                 RRRR   AAAAA  N N N  D   D  O   O  M M M                    %
   8 %                 R R    A   A  N  NN  D   D  O   O  M   M                    %
   9 %                 R  R   A   A  N   N  DDDD    OOO   M   M                    %
  10 %                                                                             %
  11 %                                                                             %
  12 %               MagickCore Methods to Generate Random Numbers                 %
  13 %                                                                             %
  14 %                             Software Design                                 %
  15 %                                  Cristy                                     %
  16 %                              December 2001                                  %
  17 %                                                                             %
  18 %                                                                             %
  19 %  Copyright 1999-2017 ImageMagick Studio LLC, a non-profit organization      %
  20 %  dedicated to making software imaging solutions freely available.           %
  21 %                                                                             %
  22 %  You may not use this file except in compliance with the License.  You may  %
  23 %  obtain a copy of the License at                                            %
  24 %                                                                             %
  25 %    https://www.imagemagick.org/script/license.php                           %
  26 %                                                                             %
  27 %  Unless required by applicable law or agreed to in writing, software        %
  28 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  29 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  30 %  See the License for the specific language governing permissions and        %
  31 %  limitations under the License.                                             %
  32 %                                                                             %
  33 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  34 %
  35 %  The generation of random numbers is too important to be left to chance.
  36 %                               -- Tom Christiansen <tchrist@mox.perl.com>
  37 %
  38 %
  39 */
  40 \f
  41 /*
  42   Include declarations.
  43 */
  44 #if defined(__VMS)
  45 #include <time.h>
  46 #endif
  47 #if defined(__MINGW32__) || defined(__MINGW64__)
  48 #include <sys/time.h>
  49 #endif
  50 #include "MagickCore/studio.h"
  51 #include "MagickCore/exception.h"
  52 #include "MagickCore/exception-private.h"
  53 #include "MagickCore/image-private.h"
  54 #include "MagickCore/memory_.h"
  55 #include "MagickCore/semaphore.h"
  56 #include "MagickCore/random_.h"
  57 #include "MagickCore/random-private.h"
  58 #include "MagickCore/resource_.h"
  59 #include "MagickCore/signature-private.h"
  60 #include "MagickCore/string_.h"
  61 #include "MagickCore/thread_.h"
  62 #include "MagickCore/thread-private.h"
  63 #include "MagickCore/utility.h"
  64 #include "MagickCore/utility-private.h"
  65 /*
  66   Define declarations.
  67 */
  68 #define PseudoRandomHash  SHA256Hash
  69 #define RandomEntropyLevel  9
  70 #define RandomFilename  "reservoir.xdm"
  71 #define RandomFiletype  "random"
  72 #define RandomProtocolMajorVersion  1
  73 #define RandomProtocolMinorVersion  0
  74 \f
  75 /*
  76   Typedef declarations.
  77 */
  78 struct _RandomInfo
  79 {
  80   SignatureInfo
  81     *signature_info;
  82
  83   StringInfo
  84     *nonce,
  85     *reservoir;
  86
  87   size_t
  88     i;
  89
  90   unsigned long
  91     seed[4];
  92
  93   double
  94     normalize;
  95
  96   unsigned long
  97     secret_key;
  98
  99   unsigned short
 100     protocol_major,
 101     protocol_minor;
 102
 103   SemaphoreInfo
 104     *semaphore;
 105
 106   ssize_t
 107     timestamp;
 108
 109   size_t
 110     signature;
 111 };
 112 \f
 113 /*
 114   External declarations.
 115 */
 116 #if defined(__APPLE__) && !defined(TARGET_OS_IPHONE)
 117 #include <crt_externs.h>
 118 #define environ (*_NSGetEnviron())
 119 #endif
 120
 121 #if !defined(MAGICKCORE_WINDOWS_SUPPORT)
 122 extern char
 123   **environ;
 124 #endif
 125 \f
 126 /*
 127   Global declarations.
 128 */
 129 static SemaphoreInfo
 130   *random_semaphore = (SemaphoreInfo *) NULL;
 131
 132 static unsigned long
 133   secret_key = ~0UL;
 134
 135 static MagickBooleanType
 136   gather_true_random = MagickFalse;
 137 \f
 138 /*
 139   Forward declarations.
 140 */
 141 static StringInfo
 142   *GenerateEntropicChaos(RandomInfo *);
 143 \f
 144 /*
 145 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 146 %                                                                             %
 147 %                                                                             %
 148 %                                                                             %
 149 %   A c q u i r e R a n d o m I n f o                                         %
 150 %                                                                             %
 151 %                                                                             %
 152 %                                                                             %
 153 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 154 %
 155 %  AcquireRandomInfo() allocates the RandomInfo structure.
 156 %
 157 %  The format of the AcquireRandomInfo method is:
 158 %
 159 %      RandomInfo *AcquireRandomInfo(void)
 160 %
 161 */
 162
 163 MagickExport RandomInfo *AcquireRandomInfo(void)
 164 {
 165   const StringInfo
 166     *digest;
 167
 168   RandomInfo
 169     *random_info;
 170
 171   StringInfo
 172     *entropy,
 173     *key,
 174     *nonce;
 175
 176   random_info=(RandomInfo *) AcquireMagickMemory(sizeof(*random_info));
 177   if (random_info == (RandomInfo *) NULL)
 178     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
 179   (void) ResetMagickMemory(random_info,0,sizeof(*random_info));
 180   random_info->signature_info=AcquireSignatureInfo();
 181   random_info->nonce=AcquireStringInfo(2*GetSignatureDigestsize(
 182     random_info->signature_info));
 183   ResetStringInfo(random_info->nonce);
 184   random_info->reservoir=AcquireStringInfo(GetSignatureDigestsize(
 185     random_info->signature_info));
 186   ResetStringInfo(random_info->reservoir);
 187   random_info->normalize=1.0/(~0UL);
 188   random_info->secret_key=secret_key;
 189   random_info->protocol_major=RandomProtocolMajorVersion;
 190   random_info->protocol_minor=RandomProtocolMinorVersion;
 191   random_info->semaphore=AcquireSemaphoreInfo();
 192   random_info->timestamp=(ssize_t) time(0);
 193   random_info->signature=MagickCoreSignature;
 194   /*
 195     Seed random nonce.
 196   */
 197   nonce=GenerateEntropicChaos(random_info);
 198   if (nonce == (StringInfo *) NULL)
 199     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
 200   InitializeSignature(random_info->signature_info);
 201   UpdateSignature(random_info->signature_info,nonce);
 202   FinalizeSignature(random_info->signature_info);
 203   SetStringInfoLength(nonce,(GetSignatureDigestsize(
 204     random_info->signature_info)+1)/2);
 205   SetStringInfo(nonce,GetSignatureDigest(random_info->signature_info));
 206   SetStringInfo(random_info->nonce,nonce);
 207   nonce=DestroyStringInfo(nonce);
 208   /*
 209     Seed random reservoir with entropic data.
 210   */
 211   entropy=GenerateEntropicChaos(random_info);
 212   if (entropy == (StringInfo *) NULL)
 213     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
 214   UpdateSignature(random_info->signature_info,entropy);
 215   FinalizeSignature(random_info->signature_info);
 216   SetStringInfo(random_info->reservoir,GetSignatureDigest(
 217     random_info->signature_info));
 218   entropy=DestroyStringInfo(entropy);
 219   /*
 220     Seed pseudo random number generator.
 221   */
 222   if (random_info->secret_key == ~0UL)
 223     {
 224       key=GetRandomKey(random_info,sizeof(random_info->secret_key));
 225       (void) CopyMagickMemory(random_info->seed,GetStringInfoDatum(key),
 226         GetStringInfoLength(key));
 227       key=DestroyStringInfo(key);
 228     }
 229   else
 230     {
 231       SignatureInfo
 232         *signature_info;
 233
 234       signature_info=AcquireSignatureInfo();
 235       key=AcquireStringInfo(sizeof(random_info->secret_key));
 236       SetStringInfoDatum(key,(unsigned char *) &random_info->secret_key);
 237       UpdateSignature(signature_info,key);
 238       key=DestroyStringInfo(key);
 239       FinalizeSignature(signature_info);
 240       digest=GetSignatureDigest(signature_info);
 241       (void) CopyMagickMemory(random_info->seed,GetStringInfoDatum(digest),
 242         MagickMin(GetSignatureDigestsize(signature_info),
 243         sizeof(*random_info->seed)));
 244       signature_info=DestroySignatureInfo(signature_info);
 245     }
 246   random_info->seed[1]=0x50a7f451UL;
 247   random_info->seed[2]=0x5365417eUL;
 248   random_info->seed[3]=0xc3a4171aUL;
 249   return(random_info);
 250 }
 251 \f
 252 /*
 253 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 254 %                                                                             %
 255 %                                                                             %
 256 %                                                                             %
 257 +   D e s t r o y R a n d o m I n f o                                         %
 258 %                                                                             %
 259 %                                                                             %
 260 %                                                                             %
 261 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 262 %
 263 %  DestroyRandomInfo() deallocates memory associated with the random
 264 %  reservoir.
 265 %
 266 %  The format of the DestroyRandomInfo method is:
 267 %
 268 %      RandomInfo *DestroyRandomInfo(RandomInfo *random_info)
 269 %
 270 %  A description of each parameter follows:
 271 %
 272 %    o random_info: the random info.
 273 %
 274 */
 275 MagickExport RandomInfo *DestroyRandomInfo(RandomInfo *random_info)
 276 {
 277   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
 278   assert(random_info != (RandomInfo *) NULL);
 279   assert(random_info->signature == MagickCoreSignature);
 280   LockSemaphoreInfo(random_info->semaphore);
 281   if (random_info->reservoir != (StringInfo *) NULL)
 282     random_info->reservoir=DestroyStringInfo(random_info->reservoir);
 283   if (random_info->nonce != (StringInfo *) NULL)
 284     random_info->nonce=DestroyStringInfo(random_info->nonce);
 285   if (random_info->signature_info != (SignatureInfo *) NULL)
 286     random_info->signature_info=DestroySignatureInfo(
 287       random_info->signature_info);
 288   (void) ResetMagickMemory(random_info->seed,0,sizeof(*random_info->seed));
 289   random_info->signature=(~MagickCoreSignature);
 290   UnlockSemaphoreInfo(random_info->semaphore);
 291   RelinquishSemaphoreInfo(&random_info->semaphore);
 292   random_info=(RandomInfo *) RelinquishMagickMemory(random_info);
 293   return(random_info);
 294 }
 295 \f
 296 /*
 297 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 298 %                                                                             %
 299 %                                                                             %
 300 %                                                                             %
 301 +   G e n e r a t e E n t r o p i c C h a o s                                 %
 302 %                                                                             %
 303 %                                                                             %
 304 %                                                                             %
 305 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 306 %
 307 %  GenerateEntropicChaos() generate entropic chaos used to initialize the
 308 %  random reservoir.
 309 %
 310 %  The format of the GenerateEntropicChaos method is:
 311 %
 312 %      StringInfo *GenerateEntropicChaos(RandomInfo *random_info)
 313 %
 314 %  A description of each parameter follows:
 315 %
 316 %    o random_info: the random info.
 317 %
 318 */
 319
 320 #if !defined(MAGICKCORE_WINDOWS_SUPPORT)
 321 static ssize_t ReadRandom(int file,unsigned char *source,size_t length)
 322 {
 323   register unsigned char
 324     *q;
 325
 326   ssize_t
 327     offset,
 328     count;
 329
 330   offset=0;
 331   for (q=source; length != 0; length-=count)
 332   {
 333     count=(ssize_t) read(file,q,length);
 334     if (count <= 0)
 335       {
 336         count=0;
 337         if (errno == EINTR)
 338           continue;
 339         return(-1);
 340       }
 341     q+=count;
 342     offset+=count;
 343   }
 344   return(offset);
 345 }
 346 #endif
 347
 348 static StringInfo *GenerateEntropicChaos(RandomInfo *random_info)
 349 {
 350 #define MaxEntropyExtent  64
 351
 352   MagickThreadType
 353     tid;
 354
 355   StringInfo
 356     *chaos,
 357     *entropy;
 358
 359   size_t
 360     nanoseconds,
 361     seconds;
 362
 363   ssize_t
 364     pid;
 365
 366   /*
 367     Initialize random reservoir.
 368   */
 369   entropy=AcquireStringInfo(0);
 370   LockSemaphoreInfo(random_info->semaphore);
 371   chaos=AcquireStringInfo(sizeof(unsigned char *));
 372   SetStringInfoDatum(chaos,(unsigned char *) &entropy);
 373   ConcatenateStringInfo(entropy,chaos);
 374   SetStringInfoDatum(chaos,(unsigned char *) entropy);
 375   ConcatenateStringInfo(entropy,chaos);
 376   pid=(ssize_t) getpid();
 377   SetStringInfoLength(chaos,sizeof(pid));
 378   SetStringInfoDatum(chaos,(unsigned char *) &pid);
 379   ConcatenateStringInfo(entropy,chaos);
 380   tid=GetMagickThreadId();
 381   SetStringInfoLength(chaos,sizeof(tid));
 382   SetStringInfoDatum(chaos,(unsigned char *) &tid);
 383   ConcatenateStringInfo(entropy,chaos);
 384 #if defined(MAGICKCORE_HAVE_SYSCONF) && defined(_SC_PHYS_PAGES)
 385   {
 386     ssize_t
 387       pages;
 388
 389     pages=(ssize_t) sysconf(_SC_PHYS_PAGES);
 390     SetStringInfoLength(chaos,sizeof(pages));
 391     SetStringInfoDatum(chaos,(unsigned char *) &pages);
 392     ConcatenateStringInfo(entropy,chaos);
 393   }
 394 #endif
 395 #if defined(MAGICKCORE_HAVE_GETRUSAGE) && defined(RUSAGE_SELF)
 396   {
 397     struct rusage
 398       usage;
 399
 400     if (getrusage(RUSAGE_SELF,&usage) == 0)
 401       {
 402         SetStringInfoLength(chaos,sizeof(usage));
 403         SetStringInfoDatum(chaos,(unsigned char *) &usage);
 404       }
 405   }
 406 #endif
 407   seconds=time((time_t *) 0);
 408   nanoseconds=0;
 409 #if defined(MAGICKCORE_HAVE_GETTIMEOFDAY)
 410   {
 411     struct timeval
 412       timer;
 413
 414     if (gettimeofday(&timer,(struct timezone *) NULL) == 0)
 415       {
 416         seconds=timer.tv_sec;
 417         nanoseconds=1000UL*timer.tv_usec;
 418       }
 419   }
 420 #endif
 421 #if defined(MAGICKCORE_HAVE_CLOCK_GETTIME) && defined(CLOCK_REALTIME_HR)
 422   {
 423     struct timespec
 424       timer;
 425
 426     if (clock_gettime(CLOCK_REALTIME_HR,&timer) == 0)
 427       {
 428         seconds=timer.tv_sec;
 429         nanoseconds=timer.tv_nsec;
 430       }
 431   }
 432 #endif
 433   SetStringInfoLength(chaos,sizeof(seconds));
 434   SetStringInfoDatum(chaos,(unsigned char *) &seconds);
 435   ConcatenateStringInfo(entropy,chaos);
 436   SetStringInfoLength(chaos,sizeof(nanoseconds));
 437   SetStringInfoDatum(chaos,(unsigned char *) &nanoseconds);
 438   ConcatenateStringInfo(entropy,chaos);
 439   nanoseconds=0;
 440 #if defined(MAGICKCORE_HAVE_CLOCK)
 441   nanoseconds=clock();
 442 #endif
 443 #if defined(MAGICKCORE_HAVE_TIMES)
 444   {
 445     struct tms
 446       timer;
 447
 448     (void) times(&timer);
 449     nanoseconds=timer.tms_utime+timer.tms_stime;
 450   }
 451 #endif
 452   SetStringInfoLength(chaos,sizeof(nanoseconds));
 453   SetStringInfoDatum(chaos,(unsigned char *) &nanoseconds);
 454   ConcatenateStringInfo(entropy,chaos);
 455 #if defined(MAGICKCORE_HAVE_MKSTEMP)
 456   {
 457     char
 458       path[MagickPathExtent];
 459
 460     int
 461       file;
 462
 463     (void) strcpy(path,"XXXXXX");
 464     file=mkstemp(path);
 465     if (file != -1)
 466       {
 467 #if defined(MAGICKCORE_HAVE_FCHMOD)
 468         (void) fchmod(file,0600);
 469 #endif
 470 #if defined(__OS2__)
 471         setmode(file,O_BINARY);
 472 #endif
 473         (void) close(file);
 474       }
 475     (void) remove_utf8(path);
 476     SetStringInfoLength(chaos,strlen(path));
 477     SetStringInfoDatum(chaos,(unsigned char *) path);
 478     ConcatenateStringInfo(entropy,chaos);
 479   }
 480 #endif
 481 #if defined(MAGICKCORE_WINDOWS_SUPPORT)
 482   {
 483     double
 484       datum;
 485
 486     LARGE_INTEGER
 487       datum1;
 488
 489     /*
 490       Not crytographically strong but better than nothing.
 491     */
 492     datum=NTElapsedTime()+NTUserTime();
 493     SetStringInfoLength(chaos,sizeof(datum));
 494     SetStringInfoDatum(chaos,(unsigned char *) &datum);
 495     ConcatenateStringInfo(entropy,chaos);
 496     if (QueryPerformanceCounter(&datum1) != 0)
 497       {
 498         SetStringInfoLength(chaos,sizeof(datum1));
 499         SetStringInfoDatum(chaos,(unsigned char *) &datum1);
 500         ConcatenateStringInfo(entropy,chaos);
 501       }
 502     /*
 503       Our best hope for true entropy.
 504     */
 505     SetStringInfoLength(chaos,MaxEntropyExtent);
 506     (void) NTGatherRandomData(MaxEntropyExtent,GetStringInfoDatum(chaos));
 507     ConcatenateStringInfo(entropy,chaos);
 508   }
 509 #else
 510   {
 511     char
 512       *filename;
 513
 514     int
 515       file;
 516
 517     ssize_t
 518       count;
 519
 520     StringInfo
 521       *device;
 522
 523     /*
 524       Not crytographically strong but better than nothing.
 525     */
 526     if (environ != (char **) NULL)
 527       {
 528         register ssize_t
 529           i;
 530
 531         /*
 532           Squeeze some entropy from the sometimes unpredicatble environment.
 533         */
 534         for (i=0; environ[i] != (char *) NULL; i++)
 535         {
 536           SetStringInfoLength(chaos,strlen(environ[i]));
 537           SetStringInfoDatum(chaos,(unsigned char *) environ[i]);
 538           ConcatenateStringInfo(entropy,chaos);
 539         }
 540       }
 541     filename=AcquireString("/dev/urandom");
 542     device=StringToStringInfo(filename);
 543     device=DestroyStringInfo(device);
 544     file=open_utf8(filename,O_RDONLY | O_BINARY,0);
 545     filename=DestroyString(filename);
 546     if (file != -1)
 547       {
 548         SetStringInfoLength(chaos,MaxEntropyExtent);
 549         count=ReadRandom(file,GetStringInfoDatum(chaos),MaxEntropyExtent);
 550         (void) close(file);
 551         SetStringInfoLength(chaos,(size_t) count);
 552         ConcatenateStringInfo(entropy,chaos);
 553       }
 554     if (gather_true_random != MagickFalse)
 555       {
 556         /*
 557           Our best hope for true entropy.
 558         */
 559         filename=AcquireString("/dev/random");
 560         device=StringToStringInfo(filename);
 561         device=DestroyStringInfo(device);
 562         file=open_utf8(filename,O_RDONLY | O_BINARY,0);
 563         filename=DestroyString(filename);
 564         if (file == -1)
 565           {
 566             filename=AcquireString("/dev/srandom");
 567             device=StringToStringInfo(filename);
 568             device=DestroyStringInfo(device);
 569             file=open_utf8(filename,O_RDONLY | O_BINARY,0);
 570           }
 571         if (file != -1)
 572           {
 573             SetStringInfoLength(chaos,MaxEntropyExtent);
 574             count=ReadRandom(file,GetStringInfoDatum(chaos),MaxEntropyExtent);
 575             (void) close(file);
 576             SetStringInfoLength(chaos,(size_t) count);
 577             ConcatenateStringInfo(entropy,chaos);
 578           }
 579       }
 580   }
 581 #endif
 582   chaos=DestroyStringInfo(chaos);
 583   UnlockSemaphoreInfo(random_info->semaphore);
 584   return(entropy);
 585 }
 586 \f
 587 /*
 588 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 589 %                                                                             %
 590 %                                                                             %
 591 %                                                                             %
 592 %   G e t P s e u d o R a n d o m V a l u e                                   %
 593 %                                                                             %
 594 %                                                                             %
 595 %                                                                             %
 596 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 597 %
 598 %  GetPseudoRandomValue() return a non-negative double-precision floating-point
 599 %  value uniformly distributed over the interval [0.0, 1.0) with a 2 to the
 600 %  128th-1 period.
 601 %
 602 %  The format of the GetPseudoRandomValue method is:
 603 %
 604 %      double GetPseudoRandomValue(RandomInfo *randon_info)
 605 %
 606 %  A description of each parameter follows:
 607 %
 608 %    o random_info: the random info.
 609 %
 610 */
 611 MagickExport double GetPseudoRandomValue(RandomInfo *random_info)
 612 {
 613   register unsigned long
 614     *seed;
 615
 616   unsigned long
 617     alpha;
 618
 619   seed=random_info->seed;
 620   do
 621   {
 622     alpha=(unsigned long) (seed[1] ^ (seed[1] << 11));
 623     seed[1]=seed[2];
 624     seed[2]=seed[3];
 625     seed[3]=seed[0];
 626     seed[0]=(seed[0] ^ (seed[0] >> 19)) ^ (alpha ^ (alpha >> 8));
 627   } while (seed[0] == ~0UL);
 628   return(random_info->normalize*seed[0]);
 629 }
 630 \f
 631 /*
 632 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 633 %                                                                             %
 634 %                                                                             %
 635 %                                                                             %
 636 +   G e t R a n d o m I n f o N o r m a l i z e                               %
 637 %                                                                             %
 638 %                                                                             %
 639 %                                                                             %
 640 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 641 %
 642 %  GetRandomInfoNormalize() returns the random normalize value.
 643 %
 644 %  The format of the GetRandomInfoNormalize method is:
 645 %
 646 %      double GetRandomInfoNormalize(const RandomInfo *random_info)
 647 %
 648 %  A description of each parameter follows:
 649 %
 650 %    o random_info: the random info.
 651 %
 652 */
 653 MagickPrivate double GetRandomInfoNormalize(const RandomInfo *random_info)
 654 {
 655   assert(random_info != (const RandomInfo *) NULL);
 656   return(random_info->normalize);
 657 }
 658 \f
 659 /*
 660 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 661 %                                                                             %
 662 %                                                                             %
 663 %                                                                             %
 664 +   G e t R a n d o m I n f o S e e d                                         %
 665 %                                                                             %
 666 %                                                                             %
 667 %                                                                             %
 668 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 669 %
 670 %  GetRandomInfoSeed() returns the random seed.
 671 %
 672 %  The format of the GetRandomInfoSeed method is:
 673 %
 674 %      unsigned long *GetRandomInfoSeed(RandomInfo *random_info)
 675 %
 676 %  A description of each parameter follows:
 677 %
 678 %    o random_info: the random info.
 679 %
 680 */
 681 MagickPrivate unsigned long *GetRandomInfoSeed(RandomInfo *random_info)
 682 {
 683   assert(random_info != (RandomInfo *) NULL);
 684   return(random_info->seed);
 685 }
 686 \f
 687 /*
 688 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 689 %                                                                             %
 690 %                                                                             %
 691 %                                                                             %
 692 %   G e t R a n d o m K e y                                                   %
 693 %                                                                             %
 694 %                                                                             %
 695 %                                                                             %
 696 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 697 %
 698 %  GetRandomKey() gets a random key from the reservoir.
 699 %
 700 %  The format of the GetRandomKey method is:
 701 %
 702 %      StringInfo *GetRandomKey(RandomInfo *random_info,const size_t length)
 703 %
 704 %  A description of each parameter follows:
 705 %
 706 %    o random_info: the random info.
 707 %
 708 %    o length: the key length.
 709 %
 710 */
 711 MagickExport StringInfo *GetRandomKey(RandomInfo *random_info,
 712   const size_t length)
 713 {
 714   StringInfo
 715     *key;
 716
 717   assert(random_info != (RandomInfo *) NULL);
 718   key=AcquireStringInfo(length);
 719   SetRandomKey(random_info,length,GetStringInfoDatum(key));
 720   return(key);
 721 }
 722 \f
 723 /*
 724 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 725 %                                                                             %
 726 %                                                                             %
 727 %                                                                             %
 728 %   G e t R a n d o m S e c r e t K e y                                       %
 729 %                                                                             %
 730 %                                                                             %
 731 %                                                                             %
 732 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 733 %
 734 %  GetRandomSecretKey() returns the random secet key.
 735 %
 736 %  The format of the GetRandomSecretKey method is:
 737 %
 738 %      unsigned long GetRandomSecretKey(const RandomInfo *random_info)
 739 %
 740 %  A description of each parameter follows:
 741 %
 742 %    o random_info: the random info.
 743 */
 744 MagickExport unsigned long GetRandomSecretKey(const RandomInfo *random_info)
 745 {
 746   return(random_info->secret_key);
 747 }
 748 \f
 749 /*
 750 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 751 %                                                                             %
 752 %                                                                             %
 753 %                                                                             %
 754 %   G e t R a n d o m V a l u e                                               %
 755 %                                                                             %
 756 %                                                                             %
 757 %                                                                             %
 758 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 759 %
 760 %  GetRandomValue() return a non-negative double-precision floating-point
 761 %  value uniformly distributed over the interval [0.0, 1.0) with a 2 to the
 762 %  128th-1 period (not cryptographically strong).
 763 %
 764 %  The format of the GetRandomValue method is:
 765 %
 766 %      double GetRandomValue(void)
 767 %
 768 */
 769 MagickExport double GetRandomValue(RandomInfo *random_info)
 770 {
 771   unsigned long
 772     key,
 773     range;
 774
 775   range=(~0UL);
 776   do
 777   {
 778     SetRandomKey(random_info,sizeof(key),(unsigned char *) &key);
 779   } while (key == range);
 780   return((double) key/range);
 781 }
 782 \f
 783 /*
 784 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 785 %                                                                             %
 786 %                                                                             %
 787 %                                                                             %
 788 +   R a n d o m C o m p o n e n t G e n e s i s                               %
 789 %                                                                             %
 790 %                                                                             %
 791 %                                                                             %
 792 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 793 %
 794 %  RandomComponentGenesis() instantiates the random component.
 795 %
 796 %  The format of the RandomComponentGenesis method is:
 797 %
 798 %      MagickBooleanType RandomComponentGenesis(void)
 799 %
 800 */
 801 MagickPrivate MagickBooleanType RandomComponentGenesis(void)
 802 {
 803   if (random_semaphore == (SemaphoreInfo *) NULL)
 804     random_semaphore=AcquireSemaphoreInfo();
 805   return(MagickTrue);
 806 }
 807 \f
 808 /*
 809 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 810 %                                                                             %
 811 %                                                                             %
 812 %                                                                             %
 813 +   R a n d o m C o m p o n e n t T e r m i n u s                             %
 814 %                                                                             %
 815 %                                                                             %
 816 %                                                                             %
 817 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 818 %
 819 %  RandomComponentTerminus() destroys the random component.
 820 %
 821 %  The format of the RandomComponentTerminus method is:
 822 %
 823 %      RandomComponentTerminus(void)
 824 %
 825 */
 826 MagickPrivate void RandomComponentTerminus(void)
 827 {
 828   if (random_semaphore == (SemaphoreInfo *) NULL)
 829     ActivateSemaphoreInfo(&random_semaphore);
 830   RelinquishSemaphoreInfo(&random_semaphore);
 831 }
 832 \f
 833 /*
 834 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 835 %                                                                             %
 836 %                                                                             %
 837 %                                                                             %
 838 %   S e t R a n d o m K e y                                                   %
 839 %                                                                             %
 840 %                                                                             %
 841 %                                                                             %
 842 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 843 %
 844 %  SetRandomKey() sets a random key from the reservoir.
 845 %
 846 %  The format of the SetRandomKey method is:
 847 %
 848 %      void SetRandomKey(RandomInfo *random_info,const size_t length,
 849 %        unsigned char *key)
 850 %
 851 %  A description of each parameter follows:
 852 %
 853 %    o random_info: the random info.
 854 %
 855 %    o length: the key length.
 856 %
 857 %    o key: the key.
 858 %
 859 */
 860
 861 static inline void IncrementRandomNonce(StringInfo *nonce)
 862 {
 863   register ssize_t
 864     i;
 865
 866   unsigned char
 867     *datum;
 868
 869   datum=GetStringInfoDatum(nonce);
 870   for (i=(ssize_t) (GetStringInfoLength(nonce)-1); i != 0; i--)
 871   {
 872     datum[i]++;
 873     if (datum[i] != 0)
 874       return;
 875   }
 876   ThrowFatalException(RandomFatalError,"SequenceWrapError");
 877 }
 878
 879 MagickExport void SetRandomKey(RandomInfo *random_info,const size_t length,
 880   unsigned char *key)
 881 {
 882   register size_t
 883     i;
 884
 885   register unsigned char
 886     *p;
 887
 888   SignatureInfo
 889     *signature_info;
 890
 891   unsigned char
 892     *datum;
 893
 894   assert(random_info != (RandomInfo *) NULL);
 895   if (length == 0)
 896     return;
 897   LockSemaphoreInfo(random_info->semaphore);
 898   signature_info=random_info->signature_info;
 899   datum=GetStringInfoDatum(random_info->reservoir);
 900   i=length;
 901   for (p=key; (i != 0) && (random_info->i != 0); i--)
 902   {
 903     *p++=datum[random_info->i];
 904     random_info->i++;
 905     if (random_info->i == GetSignatureDigestsize(signature_info))
 906       random_info->i=0;
 907   }
 908   while (i >= GetSignatureDigestsize(signature_info))
 909   {
 910     InitializeSignature(signature_info);
 911     UpdateSignature(signature_info,random_info->nonce);
 912     FinalizeSignature(signature_info);
 913     IncrementRandomNonce(random_info->nonce);
 914     (void) CopyMagickMemory(p,GetStringInfoDatum(GetSignatureDigest(
 915       signature_info)),GetSignatureDigestsize(signature_info));
 916     p+=GetSignatureDigestsize(signature_info);
 917     i-=GetSignatureDigestsize(signature_info);
 918   }
 919   if (i != 0)
 920     {
 921       InitializeSignature(signature_info);
 922       UpdateSignature(signature_info,random_info->nonce);
 923       FinalizeSignature(signature_info);
 924       IncrementRandomNonce(random_info->nonce);
 925       SetStringInfo(random_info->reservoir,GetSignatureDigest(signature_info));
 926       random_info->i=i;
 927       datum=GetStringInfoDatum(random_info->reservoir);
 928       while (i-- != 0)
 929         p[i]=datum[i];
 930     }
 931   UnlockSemaphoreInfo(random_info->semaphore);
 932 }
 933 \f
 934 /*
 935 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 936 %                                                                             %
 937 %                                                                             %
 938 %                                                                             %
 939 %   S e t R a n d o m S e c r e t K e y                                       %
 940 %                                                                             %
 941 %                                                                             %
 942 %                                                                             %
 943 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 944 %
 945 %  SetRandomSecretKey() sets the pseudo-random number generator secret key.
 946 %
 947 %  The format of the SetRandomSecretKey method is:
 948 %
 949 %      void SetRandomSecretKey(const unsigned long key)
 950 %
 951 %  A description of each parameter follows:
 952 %
 953 %    o key: the secret seed.
 954 %
 955 */
 956 MagickExport void SetRandomSecretKey(const unsigned long key)
 957 {
 958   secret_key=key;
 959 }
 960 \f
 961 /*
 962 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 963 %                                                                             %
 964 %                                                                             %
 965 %                                                                             %
 966 %   S e t R a n d o m T r u e R a n d o m                                     %
 967 %                                                                             %
 968 %                                                                             %
 969 %                                                                             %
 970 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 971 %
 972 %  SetRandomTrueRandom() declares your intentions to use true random numbers.
 973 %  True random numbers are encouraged but may not always be practical because
 974 %  your application may block while entropy is gathered from your environment.
 975 %
 976 %  The format of the SetRandomTrueRandom method is:
 977 %
 978 %      void SetRandomTrueRandom(const MagickBooleanType true_random)
 979 %
 980 %  A description of each parameter follows:
 981 %
 982 %    o true_random: declare your intentions to use true-random number.
 983 %
 984 */
 985 MagickExport void SetRandomTrueRandom(const MagickBooleanType true_random)
 986 {
 987   gather_true_random=true_random;
 988 }