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-2016 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
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
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
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
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
138 /*
139 Forward declarations.
140 */
141 static StringInfo
142 *GenerateEntropicChaos(RandomInfo *);
143
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
AcquireRandomInfo(void)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
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 */
DestroyRandomInfo(RandomInfo * random_info)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
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)
ReadRandom(int file,unsigned char * source,size_t length)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
GenerateEntropicChaos(RandomInfo * random_info)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) GetPathTemplate(path);
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 seconds;
485
486 LARGE_INTEGER
487 nanoseconds;
488
489 MagickBooleanType
490 status;
491
492 /*
493 Not crytographically strong but better than nothing.
494 */
495 seconds=NTElapsedTime()+NTUserTime();
496 SetStringInfoLength(chaos,sizeof(seconds));
497 SetStringInfoDatum(chaos,(unsigned char *) &seconds);
498 ConcatenateStringInfo(entropy,chaos);
499 if (QueryPerformanceCounter(&nanoseconds) != 0)
500 {
501 SetStringInfoLength(chaos,sizeof(nanoseconds));
502 SetStringInfoDatum(chaos,(unsigned char *) &nanoseconds);
503 ConcatenateStringInfo(entropy,chaos);
504 }
505 /*
506 Our best hope for true entropy.
507 */
508 SetStringInfoLength(chaos,MaxEntropyExtent);
509 status=NTGatherRandomData(MaxEntropyExtent,GetStringInfoDatum(chaos));
510 (void) status;
511 ConcatenateStringInfo(entropy,chaos);
512 }
513 #else
514 {
515 char
516 *filename;
517
518 int
519 file;
520
521 ssize_t
522 count;
523
524 StringInfo
525 *device;
526
527 /*
528 Not crytographically strong but better than nothing.
529 */
530 if (environ != (char **) NULL)
531 {
532 register ssize_t
533 i;
534
535 /*
536 Squeeze some entropy from the sometimes unpredicatble environment.
537 */
538 for (i=0; environ[i] != (char *) NULL; i++)
539 {
540 SetStringInfoLength(chaos,strlen(environ[i]));
541 SetStringInfoDatum(chaos,(unsigned char *) environ[i]);
542 ConcatenateStringInfo(entropy,chaos);
543 }
544 }
545 filename=AcquireString("/dev/urandom");
546 device=StringToStringInfo(filename);
547 device=DestroyStringInfo(device);
548 file=open_utf8(filename,O_RDONLY | O_BINARY,0);
549 filename=DestroyString(filename);
550 if (file != -1)
551 {
552 SetStringInfoLength(chaos,MaxEntropyExtent);
553 count=ReadRandom(file,GetStringInfoDatum(chaos),MaxEntropyExtent);
554 (void) close(file);
555 SetStringInfoLength(chaos,(size_t) count);
556 ConcatenateStringInfo(entropy,chaos);
557 }
558 if (gather_true_random != MagickFalse)
559 {
560 /*
561 Our best hope for true entropy.
562 */
563 filename=AcquireString("/dev/random");
564 device=StringToStringInfo(filename);
565 device=DestroyStringInfo(device);
566 file=open_utf8(filename,O_RDONLY | O_BINARY,0);
567 filename=DestroyString(filename);
568 if (file == -1)
569 {
570 filename=AcquireString("/dev/srandom");
571 device=StringToStringInfo(filename);
572 device=DestroyStringInfo(device);
573 file=open_utf8(filename,O_RDONLY | O_BINARY,0);
574 }
575 if (file != -1)
576 {
577 SetStringInfoLength(chaos,MaxEntropyExtent);
578 count=ReadRandom(file,GetStringInfoDatum(chaos),MaxEntropyExtent);
579 (void) close(file);
580 SetStringInfoLength(chaos,(size_t) count);
581 ConcatenateStringInfo(entropy,chaos);
582 }
583 }
584 }
585 #endif
586 chaos=DestroyStringInfo(chaos);
587 UnlockSemaphoreInfo(random_info->semaphore);
588 return(entropy);
589 }
590
591 /*
592 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
593 % %
594 % %
595 % %
596 % G e t P s e u d o R a n d o m V a l u e %
597 % %
598 % %
599 % %
600 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
601 %
602 % GetPseudoRandomValue() return a non-negative double-precision floating-point
603 % value uniformly distributed over the interval [0.0, 1.0) with a 2 to the
604 % 128th-1 period.
605 %
606 % The format of the GetPseudoRandomValue method is:
607 %
608 % double GetPseudoRandomValue(RandomInfo *randon_info)
609 %
610 % A description of each parameter follows:
611 %
612 % o random_info: the random info.
613 %
614 */
GetPseudoRandomValue(RandomInfo * random_info)615 MagickExport double GetPseudoRandomValue(RandomInfo *random_info)
616 {
617 register unsigned long
618 *seed;
619
620 unsigned long
621 alpha;
622
623 seed=random_info->seed;
624 do
625 {
626 alpha=(unsigned long) (seed[1] ^ (seed[1] << 11));
627 seed[1]=seed[2];
628 seed[2]=seed[3];
629 seed[3]=seed[0];
630 seed[0]=(seed[0] ^ (seed[0] >> 19)) ^ (alpha ^ (alpha >> 8));
631 } while (seed[0] == ~0UL);
632 return(random_info->normalize*seed[0]);
633 }
634
635 /*
636 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
637 % %
638 % %
639 % %
640 + G e t R a n d o m I n f o N o r m a l i z e %
641 % %
642 % %
643 % %
644 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
645 %
646 % GetRandomInfoNormalize() returns the random normalize value.
647 %
648 % The format of the GetRandomInfoNormalize method is:
649 %
650 % double GetRandomInfoNormalize(const RandomInfo *random_info)
651 %
652 % A description of each parameter follows:
653 %
654 % o random_info: the random info.
655 %
656 */
GetRandomInfoNormalize(const RandomInfo * random_info)657 MagickPrivate double GetRandomInfoNormalize(const RandomInfo *random_info)
658 {
659 assert(random_info != (const RandomInfo *) NULL);
660 return(random_info->normalize);
661 }
662
663 /*
664 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
665 % %
666 % %
667 % %
668 + G e t R a n d o m I n f o S e e d %
669 % %
670 % %
671 % %
672 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
673 %
674 % GetRandomInfoSeed() returns the random seed.
675 %
676 % The format of the GetRandomInfoSeed method is:
677 %
678 % unsigned long *GetRandomInfoSeed(RandomInfo *random_info)
679 %
680 % A description of each parameter follows:
681 %
682 % o random_info: the random info.
683 %
684 */
GetRandomInfoSeed(RandomInfo * random_info)685 MagickPrivate unsigned long *GetRandomInfoSeed(RandomInfo *random_info)
686 {
687 assert(random_info != (RandomInfo *) NULL);
688 return(random_info->seed);
689 }
690
691 /*
692 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
693 % %
694 % %
695 % %
696 % G e t R a n d o m K e y %
697 % %
698 % %
699 % %
700 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
701 %
702 % GetRandomKey() gets a random key from the reservoir.
703 %
704 % The format of the GetRandomKey method is:
705 %
706 % StringInfo *GetRandomKey(RandomInfo *random_info,const size_t length)
707 %
708 % A description of each parameter follows:
709 %
710 % o random_info: the random info.
711 %
712 % o length: the key length.
713 %
714 */
GetRandomKey(RandomInfo * random_info,const size_t length)715 MagickExport StringInfo *GetRandomKey(RandomInfo *random_info,
716 const size_t length)
717 {
718 StringInfo
719 *key;
720
721 assert(random_info != (RandomInfo *) NULL);
722 key=AcquireStringInfo(length);
723 SetRandomKey(random_info,length,GetStringInfoDatum(key));
724 return(key);
725 }
726
727 /*
728 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
729 % %
730 % %
731 % %
732 % G e t R a n d o m S e c r e t K e y %
733 % %
734 % %
735 % %
736 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
737 %
738 % GetRandomSecretKey() returns the random secet key.
739 %
740 % The format of the GetRandomSecretKey method is:
741 %
742 % unsigned long GetRandomSecretKey(const RandomInfo *random_info)
743 %
744 % A description of each parameter follows:
745 %
746 % o random_info: the random info.
747 */
GetRandomSecretKey(const RandomInfo * random_info)748 MagickExport unsigned long GetRandomSecretKey(const RandomInfo *random_info)
749 {
750 return(random_info->secret_key);
751 }
752
753 /*
754 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
755 % %
756 % %
757 % %
758 % G e t R a n d o m V a l u e %
759 % %
760 % %
761 % %
762 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
763 %
764 % GetRandomValue() return a non-negative double-precision floating-point
765 % value uniformly distributed over the interval [0.0, 1.0) with a 2 to the
766 % 128th-1 period (not cryptographically strong).
767 %
768 % The format of the GetRandomValue method is:
769 %
770 % double GetRandomValue(void)
771 %
772 */
GetRandomValue(RandomInfo * random_info)773 MagickExport double GetRandomValue(RandomInfo *random_info)
774 {
775 unsigned long
776 key,
777 range;
778
779 range=(~0UL);
780 do
781 {
782 SetRandomKey(random_info,sizeof(key),(unsigned char *) &key);
783 } while (key == range);
784 return((double) key/range);
785 }
786
787 /*
788 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
789 % %
790 % %
791 % %
792 + R a n d o m C o m p o n e n t G e n e s i s %
793 % %
794 % %
795 % %
796 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
797 %
798 % RandomComponentGenesis() instantiates the random component.
799 %
800 % The format of the RandomComponentGenesis method is:
801 %
802 % MagickBooleanType RandomComponentGenesis(void)
803 %
804 */
RandomComponentGenesis(void)805 MagickPrivate MagickBooleanType RandomComponentGenesis(void)
806 {
807 if (random_semaphore == (SemaphoreInfo *) NULL)
808 random_semaphore=AcquireSemaphoreInfo();
809 return(MagickTrue);
810 }
811
812 /*
813 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
814 % %
815 % %
816 % %
817 + R a n d o m C o m p o n e n t T e r m i n u s %
818 % %
819 % %
820 % %
821 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
822 %
823 % RandomComponentTerminus() destroys the random component.
824 %
825 % The format of the RandomComponentTerminus method is:
826 %
827 % RandomComponentTerminus(void)
828 %
829 */
RandomComponentTerminus(void)830 MagickPrivate void RandomComponentTerminus(void)
831 {
832 if (random_semaphore == (SemaphoreInfo *) NULL)
833 ActivateSemaphoreInfo(&random_semaphore);
834 RelinquishSemaphoreInfo(&random_semaphore);
835 }
836
837 /*
838 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
839 % %
840 % %
841 % %
842 % S e t R a n d o m K e y %
843 % %
844 % %
845 % %
846 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
847 %
848 % SetRandomKey() sets a random key from the reservoir.
849 %
850 % The format of the SetRandomKey method is:
851 %
852 % void SetRandomKey(RandomInfo *random_info,const size_t length,
853 % unsigned char *key)
854 %
855 % A description of each parameter follows:
856 %
857 % o random_info: the random info.
858 %
859 % o length: the key length.
860 %
861 % o key: the key.
862 %
863 */
864
IncrementRandomNonce(StringInfo * nonce)865 static inline void IncrementRandomNonce(StringInfo *nonce)
866 {
867 register ssize_t
868 i;
869
870 unsigned char
871 *datum;
872
873 datum=GetStringInfoDatum(nonce);
874 for (i=(ssize_t) (GetStringInfoLength(nonce)-1); i != 0; i--)
875 {
876 datum[i]++;
877 if (datum[i] != 0)
878 return;
879 }
880 ThrowFatalException(RandomFatalError,"SequenceWrapError");
881 }
882
SetRandomKey(RandomInfo * random_info,const size_t length,unsigned char * key)883 MagickExport void SetRandomKey(RandomInfo *random_info,const size_t length,
884 unsigned char *key)
885 {
886 register size_t
887 i;
888
889 register unsigned char
890 *p;
891
892 SignatureInfo
893 *signature_info;
894
895 unsigned char
896 *datum;
897
898 assert(random_info != (RandomInfo *) NULL);
899 if (length == 0)
900 return;
901 LockSemaphoreInfo(random_info->semaphore);
902 signature_info=random_info->signature_info;
903 datum=GetStringInfoDatum(random_info->reservoir);
904 i=length;
905 for (p=key; (i != 0) && (random_info->i != 0); i--)
906 {
907 *p++=datum[random_info->i];
908 random_info->i++;
909 if (random_info->i == GetSignatureDigestsize(signature_info))
910 random_info->i=0;
911 }
912 while (i >= GetSignatureDigestsize(signature_info))
913 {
914 InitializeSignature(signature_info);
915 UpdateSignature(signature_info,random_info->nonce);
916 FinalizeSignature(signature_info);
917 IncrementRandomNonce(random_info->nonce);
918 (void) CopyMagickMemory(p,GetStringInfoDatum(GetSignatureDigest(
919 signature_info)),GetSignatureDigestsize(signature_info));
920 p+=GetSignatureDigestsize(signature_info);
921 i-=GetSignatureDigestsize(signature_info);
922 }
923 if (i != 0)
924 {
925 InitializeSignature(signature_info);
926 UpdateSignature(signature_info,random_info->nonce);
927 FinalizeSignature(signature_info);
928 IncrementRandomNonce(random_info->nonce);
929 SetStringInfo(random_info->reservoir,GetSignatureDigest(signature_info));
930 random_info->i=i;
931 datum=GetStringInfoDatum(random_info->reservoir);
932 while (i-- != 0)
933 p[i]=datum[i];
934 }
935 UnlockSemaphoreInfo(random_info->semaphore);
936 }
937
938 /*
939 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
940 % %
941 % %
942 % %
943 % S e t R a n d o m S e c r e t K e y %
944 % %
945 % %
946 % %
947 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
948 %
949 % SetRandomSecretKey() sets the pseudo-random number generator secret key.
950 %
951 % The format of the SetRandomSecretKey method is:
952 %
953 % void SetRandomSecretKey(const unsigned long key)
954 %
955 % A description of each parameter follows:
956 %
957 % o key: the secret seed.
958 %
959 */
SetRandomSecretKey(const unsigned long key)960 MagickExport void SetRandomSecretKey(const unsigned long key)
961 {
962 secret_key=key;
963 }
964
965 /*
966 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
967 % %
968 % %
969 % %
970 % S e t R a n d o m T r u e R a n d o m %
971 % %
972 % %
973 % %
974 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
975 %
976 % SetRandomTrueRandom() declares your intentions to use true random numbers.
977 % True random numbers are encouraged but may not always be practical because
978 % your application may block while entropy is gathered from your environment.
979 %
980 % The format of the SetRandomTrueRandom method is:
981 %
982 % void SetRandomTrueRandom(const MagickBooleanType true_random)
983 %
984 % A description of each parameter follows:
985 %
986 % o true_random: declare your intentions to use true-random number.
987 %
988 */
SetRandomTrueRandom(const MagickBooleanType true_random)989 MagickExport void SetRandomTrueRandom(const MagickBooleanType true_random)
990 {
991 gather_true_random=true_random;
992 }
993