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-2015 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 %    http://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=MagickSignature;
 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 == MagickSignature);
 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=(~MagickSignature);
 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_GETRUSAGE) && defined(RUSAGE_SELF)
 385   {
 386     struct rusage
 387       usage;
 388
 389     if (getrusage(RUSAGE_SELF,&usage) == 0)
 390       {
 391         SetStringInfoLength(chaos,sizeof(usage));
 392         SetStringInfoDatum(chaos,(unsigned char *) &usage);
 393       }
 394   }
 395 #endif
 396   seconds=time((time_t *) 0);
 397   nanoseconds=0;
 398 #if defined(MAGICKCORE_HAVE_GETTIMEOFDAY)
 399   {
 400     struct timeval
 401       timer;
 402
 403     if (gettimeofday(&timer,(struct timezone *) NULL) == 0)
 404       {
 405         seconds=timer.tv_sec;
 406         nanoseconds=1000UL*timer.tv_usec;
 407       }
 408   }
 409 #endif
 410 #if defined(MAGICKCORE_HAVE_CLOCK_GETTIME) && defined(CLOCK_REALTIME_HR)
 411   {
 412     struct timespec
 413       timer;
 414
 415     if (clock_gettime(CLOCK_REALTIME_HR,&timer) == 0)
 416       {
 417         seconds=timer.tv_sec;
 418         nanoseconds=timer.tv_nsec;
 419       }
 420   }
 421 #endif
 422   SetStringInfoLength(chaos,sizeof(seconds));
 423   SetStringInfoDatum(chaos,(unsigned char *) &seconds);
 424   ConcatenateStringInfo(entropy,chaos);
 425   SetStringInfoLength(chaos,sizeof(nanoseconds));
 426   SetStringInfoDatum(chaos,(unsigned char *) &nanoseconds);
 427   ConcatenateStringInfo(entropy,chaos);
 428   nanoseconds=0;
 429 #if defined(MAGICKCORE_HAVE_CLOCK)
 430   nanoseconds=clock();
 431 #endif
 432 #if defined(MAGICKCORE_HAVE_TIMES)
 433   {
 434     struct tms
 435       timer;
 436
 437     (void) times(&timer);
 438     nanoseconds=timer.tms_utime+timer.tms_stime;
 439   }
 440 #endif
 441   SetStringInfoLength(chaos,sizeof(nanoseconds));
 442   SetStringInfoDatum(chaos,(unsigned char *) &nanoseconds);
 443   ConcatenateStringInfo(entropy,chaos);
 444 #if defined(MAGICKCORE_HAVE_MKSTEMP)
 445   {
 446     char
 447       path[MaxTextExtent];
 448
 449     int
 450       file;
 451
 452     (void) GetPathTemplate(path);
 453     file=mkstemp(path);
 454     if (file != -1)
 455       {
 456         (void) fchmod(file,0600);
 457 #if defined(__OS2__)
 458         setmode(file,O_BINARY);
 459 #endif
 460         (void) close(file);
 461       }
 462     (void) remove_utf8(path);
 463     SetStringInfoLength(chaos,strlen(path));
 464     SetStringInfoDatum(chaos,(unsigned char *) path);
 465     ConcatenateStringInfo(entropy,chaos);
 466   }
 467 #endif
 468 #if defined(MAGICKCORE_WINDOWS_SUPPORT)
 469   {
 470     double
 471       seconds;
 472
 473     LARGE_INTEGER
 474       nanoseconds;
 475
 476     MagickBooleanType
 477       status;
 478
 479     /*
 480       Not crytographically strong but better than nothing.
 481     */
 482     seconds=NTElapsedTime()+NTUserTime();
 483     SetStringInfoLength(chaos,sizeof(seconds));
 484     SetStringInfoDatum(chaos,(unsigned char *) &seconds);
 485     ConcatenateStringInfo(entropy,chaos);
 486     if (QueryPerformanceCounter(&nanoseconds) != 0)
 487       {
 488         SetStringInfoLength(chaos,sizeof(nanoseconds));
 489         SetStringInfoDatum(chaos,(unsigned char *) &nanoseconds);
 490         ConcatenateStringInfo(entropy,chaos);
 491       }
 492     /*
 493       Our best hope for true entropy.
 494     */
 495     SetStringInfoLength(chaos,MaxEntropyExtent);
 496     status=NTGatherRandomData(MaxEntropyExtent,GetStringInfoDatum(chaos));
 497     (void) status;
 498     ConcatenateStringInfo(entropy,chaos);
 499   }
 500 #else
 501   {
 502     char
 503       *filename;
 504
 505     int
 506       file;
 507
 508     ssize_t
 509       count;
 510
 511     StringInfo
 512       *device;
 513
 514     /*
 515       Not crytographically strong but better than nothing.
 516     */
 517     if (environ != (char **) NULL)
 518       {
 519         register ssize_t
 520           i;
 521
 522         /*
 523           Squeeze some entropy from the sometimes unpredicatble environment.
 524         */
 525         for (i=0; environ[i] != (char *) NULL; i++)
 526         {
 527           SetStringInfoLength(chaos,strlen(environ[i]));
 528           SetStringInfoDatum(chaos,(unsigned char *) environ[i]);
 529           ConcatenateStringInfo(entropy,chaos);
 530         }
 531       }
 532     filename=AcquireString("/dev/urandom");
 533     device=StringToStringInfo(filename);
 534     device=DestroyStringInfo(device);
 535     file=open_utf8(filename,O_RDONLY | O_BINARY,0);
 536     filename=DestroyString(filename);
 537     if (file != -1)
 538       {
 539         SetStringInfoLength(chaos,MaxEntropyExtent);
 540         count=ReadRandom(file,GetStringInfoDatum(chaos),MaxEntropyExtent);
 541         (void) close(file);
 542         SetStringInfoLength(chaos,(size_t) count);
 543         ConcatenateStringInfo(entropy,chaos);
 544       }
 545     if (gather_true_random != MagickFalse)
 546       {
 547         /*
 548           Our best hope for true entropy.
 549         */
 550         filename=AcquireString("/dev/random");
 551         device=StringToStringInfo(filename);
 552         device=DestroyStringInfo(device);
 553         file=open_utf8(filename,O_RDONLY | O_BINARY,0);
 554         filename=DestroyString(filename);
 555         if (file == -1)
 556           {
 557             filename=AcquireString("/dev/srandom");
 558             device=StringToStringInfo(filename);
 559             device=DestroyStringInfo(device);
 560             file=open_utf8(filename,O_RDONLY | O_BINARY,0);
 561           }
 562         if (file != -1)
 563           {
 564             SetStringInfoLength(chaos,MaxEntropyExtent);
 565             count=ReadRandom(file,GetStringInfoDatum(chaos),MaxEntropyExtent);
 566             (void) close(file);
 567             SetStringInfoLength(chaos,(size_t) count);
 568             ConcatenateStringInfo(entropy,chaos);
 569           }
 570       }
 571   }
 572 #endif
 573   chaos=DestroyStringInfo(chaos);
 574   UnlockSemaphoreInfo(random_info->semaphore);
 575   return(entropy);
 576 }
 577 \f
 578 /*
 579 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 580 %                                                                             %
 581 %                                                                             %
 582 %                                                                             %
 583 %   G e t P s e u d o R a n d o m V a l u e                                   %
 584 %                                                                             %
 585 %                                                                             %
 586 %                                                                             %
 587 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 588 %
 589 %  GetPseudoRandomValue() return a non-negative double-precision floating-point
 590 %  value uniformly distributed over the interval [0.0, 1.0) with a 2 to the
 591 %  128th-1 period.
 592 %
 593 %  The format of the GetPseudoRandomValue method is:
 594 %
 595 %      double GetPseudoRandomValue(RandomInfo *randon_info)
 596 %
 597 %  A description of each parameter follows:
 598 %
 599 %    o random_info: the random info.
 600 %
 601 */
 602 MagickExport double GetPseudoRandomValue(RandomInfo *random_info)
 603 {
 604   register unsigned long
 605     *seed;
 606
 607   unsigned long
 608     alpha;
 609
 610   seed=random_info->seed;
 611   do
 612   {
 613     alpha=(unsigned long) (seed[1] ^ (seed[1] << 11));
 614     seed[1]=seed[2];
 615     seed[2]=seed[3];
 616     seed[3]=seed[0];
 617     seed[0]=(seed[0] ^ (seed[0] >> 19)) ^ (alpha ^ (alpha >> 8));
 618   } while (seed[0] == ~0UL);
 619   return(random_info->normalize*seed[0]);
 620 }
 621 \f
 622 /*
 623 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 624 %                                                                             %
 625 %                                                                             %
 626 %                                                                             %
 627 %   G e t R a n d o m K e y                                                   %
 628 %                                                                             %
 629 %                                                                             %
 630 %                                                                             %
 631 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 632 %
 633 %  GetRandomKey() gets a random key from the reservoir.
 634 %
 635 %  The format of the GetRandomKey method is:
 636 %
 637 %      StringInfo *GetRandomKey(RandomInfo *random_info,const size_t length)
 638 %
 639 %  A description of each parameter follows:
 640 %
 641 %    o random_info: the random info.
 642 %
 643 %    o length: the key length.
 644 %
 645 */
 646 MagickExport StringInfo *GetRandomKey(RandomInfo *random_info,
 647   const size_t length)
 648 {
 649   StringInfo
 650     *key;
 651
 652   assert(random_info != (RandomInfo *) NULL);
 653   key=AcquireStringInfo(length);
 654   SetRandomKey(random_info,length,GetStringInfoDatum(key));
 655   return(key);
 656 }
 657 \f
 658 /*
 659 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 660 %                                                                             %
 661 %                                                                             %
 662 %                                                                             %
 663 %   G e t R a n d o m S e c r e t K e y                                       %
 664 %                                                                             %
 665 %                                                                             %
 666 %                                                                             %
 667 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 668 %
 669 %  GetRandomSecretKey() returns the random secet key.
 670 %
 671 %  The format of the GetRandomSecretKey method is:
 672 %
 673 %      unsigned long GetRandomSecretKey(const RandomInfo *random_info)
 674 %
 675 %  A description of each parameter follows:
 676 %
 677 %    o random_info: the random info.
 678 */
 679 MagickExport unsigned long GetRandomSecretKey(const RandomInfo *random_info)
 680 {
 681   return(random_info->secret_key);
 682 }
 683 \f
 684 /*
 685 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 686 %                                                                             %
 687 %                                                                             %
 688 %                                                                             %
 689 %   G e t R a n d o m V a l u e                                               %
 690 %                                                                             %
 691 %                                                                             %
 692 %                                                                             %
 693 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 694 %
 695 %  GetRandomValue() return a non-negative double-precision floating-point
 696 %  value uniformly distributed over the interval [0.0, 1.0) with a 2 to the
 697 %  128th-1 period (not cryptographically strong).
 698 %
 699 %  The format of the GetRandomValue method is:
 700 %
 701 %      double GetRandomValue(void)
 702 %
 703 */
 704 MagickExport double GetRandomValue(RandomInfo *random_info)
 705 {
 706   unsigned long
 707     key,
 708     range;
 709
 710   range=(~0UL);
 711   do
 712   {
 713     SetRandomKey(random_info,sizeof(key),(unsigned char *) &key);
 714   } while (key == range);
 715   return((double) key/range);
 716 }
 717 \f
 718 /*
 719 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 720 %                                                                             %
 721 %                                                                             %
 722 %                                                                             %
 723 +   R a n d o m C o m p o n e n t G e n e s i s                               %
 724 %                                                                             %
 725 %                                                                             %
 726 %                                                                             %
 727 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 728 %
 729 %  RandomComponentGenesis() instantiates the random component.
 730 %
 731 %  The format of the RandomComponentGenesis method is:
 732 %
 733 %      MagickBooleanType RandomComponentGenesis(void)
 734 %
 735 */
 736 MagickPrivate MagickBooleanType RandomComponentGenesis(void)
 737 {
 738   if (random_semaphore == (SemaphoreInfo *) NULL)
 739     random_semaphore=AcquireSemaphoreInfo();
 740   return(MagickTrue);
 741 }
 742 \f
 743 /*
 744 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 745 %                                                                             %
 746 %                                                                             %
 747 %                                                                             %
 748 +   R a n d o m C o m p o n e n t T e r m i n u s                             %
 749 %                                                                             %
 750 %                                                                             %
 751 %                                                                             %
 752 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 753 %
 754 %  RandomComponentTerminus() destroys the random component.
 755 %
 756 %  The format of the RandomComponentTerminus method is:
 757 %
 758 %      RandomComponentTerminus(void)
 759 %
 760 */
 761 MagickPrivate void RandomComponentTerminus(void)
 762 {
 763   if (random_semaphore == (SemaphoreInfo *) NULL)
 764     ActivateSemaphoreInfo(&random_semaphore);
 765   RelinquishSemaphoreInfo(&random_semaphore);
 766 }
 767 \f
 768 /*
 769 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 770 %                                                                             %
 771 %                                                                             %
 772 %                                                                             %
 773 %   S e t R a n d o m K e y                                                   %
 774 %                                                                             %
 775 %                                                                             %
 776 %                                                                             %
 777 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 778 %
 779 %  SetRandomKey() sets a random key from the reservoir.
 780 %
 781 %  The format of the SetRandomKey method is:
 782 %
 783 %      void SetRandomKey(RandomInfo *random_info,const size_t length,
 784 %        unsigned char *key)
 785 %
 786 %  A description of each parameter follows:
 787 %
 788 %    o random_info: the random info.
 789 %
 790 %    o length: the key length.
 791 %
 792 %    o key: the key.
 793 %
 794 */
 795
 796 static inline void IncrementRandomNonce(StringInfo *nonce)
 797 {
 798   register ssize_t
 799     i;
 800
 801   unsigned char
 802     *datum;
 803
 804   datum=GetStringInfoDatum(nonce);
 805   for (i=(ssize_t) (GetStringInfoLength(nonce)-1); i != 0; i--)
 806   {
 807     datum[i]++;
 808     if (datum[i] != 0)
 809       return;
 810   }
 811   ThrowFatalException(RandomFatalError,"SequenceWrapError");
 812 }
 813
 814 MagickExport void SetRandomKey(RandomInfo *random_info,const size_t length,
 815   unsigned char *key)
 816 {
 817   register size_t
 818     i;
 819
 820   register unsigned char
 821     *p;
 822
 823   SignatureInfo
 824     *signature_info;
 825
 826   unsigned char
 827     *datum;
 828
 829   assert(random_info != (RandomInfo *) NULL);
 830   if (length == 0)
 831     return;
 832   LockSemaphoreInfo(random_info->semaphore);
 833   signature_info=random_info->signature_info;
 834   datum=GetStringInfoDatum(random_info->reservoir);
 835   i=length;
 836   for (p=key; (i != 0) && (random_info->i != 0); i--)
 837   {
 838     *p++=datum[random_info->i];
 839     random_info->i++;
 840     if (random_info->i == GetSignatureDigestsize(signature_info))
 841       random_info->i=0;
 842   }
 843   while (i >= GetSignatureDigestsize(signature_info))
 844   {
 845     InitializeSignature(signature_info);
 846     UpdateSignature(signature_info,random_info->nonce);
 847     FinalizeSignature(signature_info);
 848     IncrementRandomNonce(random_info->nonce);
 849     (void) CopyMagickMemory(p,GetStringInfoDatum(GetSignatureDigest(
 850       signature_info)),GetSignatureDigestsize(signature_info));
 851     p+=GetSignatureDigestsize(signature_info);
 852     i-=GetSignatureDigestsize(signature_info);
 853   }
 854   if (i != 0)
 855     {
 856       InitializeSignature(signature_info);
 857       UpdateSignature(signature_info,random_info->nonce);
 858       FinalizeSignature(signature_info);
 859       IncrementRandomNonce(random_info->nonce);
 860       SetStringInfo(random_info->reservoir,GetSignatureDigest(signature_info));
 861       random_info->i=i;
 862       datum=GetStringInfoDatum(random_info->reservoir);
 863       while (i-- != 0)
 864         p[i]=datum[i];
 865     }
 866   UnlockSemaphoreInfo(random_info->semaphore);
 867 }
 868 \f
 869 /*
 870 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 871 %                                                                             %
 872 %                                                                             %
 873 %                                                                             %
 874 %   S e t R a n d o m S e c r e t K e y                                       %
 875 %                                                                             %
 876 %                                                                             %
 877 %                                                                             %
 878 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 879 %
 880 %  SetRandomSecretKey() sets the pseudo-random number generator secret key.
 881 %
 882 %  The format of the SetRandomSecretKey method is:
 883 %
 884 %      void SetRandomSecretKey(const unsigned long key)
 885 %
 886 %  A description of each parameter follows:
 887 %
 888 %    o key: the secret seed.
 889 %
 890 */
 891 MagickExport void SetRandomSecretKey(const unsigned long key)
 892 {
 893   secret_key=key;
 894 }
 895 \f
 896 /*
 897 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 898 %                                                                             %
 899 %                                                                             %
 900 %                                                                             %
 901 %   S e t R a n d o m T r u e R a n d o m                                     %
 902 %                                                                             %
 903 %                                                                             %
 904 %                                                                             %
 905 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 906 %
 907 %  SetRandomTrueRandom() declares your intentions to use true random numbers.
 908 %  True random numbers are encouraged but may not always be practical because
 909 %  your application may block while entropy is gathered from your environment.
 910 %
 911 %  The format of the SetRandomTrueRandom method is:
 912 %
 913 %      void SetRandomTrueRandom(const MagickBooleanType true_random)
 914 %
 915 %  A description of each parameter follows:
 916 %
 917 %    o true_random: declare your intentions to use true-random number.
 918 %
 919 */
 920 MagickExport void SetRandomTrueRandom(const MagickBooleanType true_random)
 921 {
 922   gather_true_random=true_random;
 923 }
 924
 925 MagickPrivate unsigned long *GetRandomInfoSeed(RandomInfo *random_info)
 926 {
 927   assert(random_info != (RandomInfo *) NULL);
 928   return random_info->seed;
 929 }
 930
 931 MagickPrivate double GetRandomInfoNormalize(RandomInfo *random_info)
 932 {
 933   assert(random_info != (RandomInfo *) NULL);
 934   return random_info->normalize;
 935 }