MagickCore 7.1.2
Convert, Edit, Or Compose Bitmap Images
Loading...
Searching...
No Matches
policy.c
1/*
2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3% %
4% %
5% PPPP OOO L IIIII CCCC Y Y %
6% P P O O L I C Y Y %
7% PPPP O O L I C Y %
8% P O O L I C Y %
9% P OOO LLLLL IIIII CCCC Y %
10% %
11% %
12% MagickCore Policy Methods %
13% %
14% Software Design %
15% Cristy %
16% July 1992 %
17% %
18% %
19% Copyright @ 1999 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://imagemagick.org/license/ %
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*/
36␌
37/*
38 Include declarations.
39*/
40#include "MagickCore/studio.h"
41#include "MagickCore/cache-private.h"
42#include "MagickCore/client.h"
43#include "MagickCore/configure.h"
44#include "MagickCore/configure-private.h"
45#include "MagickCore/exception.h"
46#include "MagickCore/exception-private.h"
47#include "MagickCore/linked-list-private.h"
48#include "MagickCore/magick-private.h"
49#include "MagickCore/memory_.h"
50#include "MagickCore/memory-private.h"
51#include "MagickCore/monitor.h"
52#include "MagickCore/monitor-private.h"
53#include "MagickCore/option.h"
54#include "MagickCore/policy.h"
55#include "MagickCore/policy-private.h"
56#include "MagickCore/resource_.h"
57#include "MagickCore/resource-private.h"
58#include "MagickCore/semaphore.h"
59#include "MagickCore/stream-private.h"
60#include "MagickCore/string_.h"
61#include "MagickCore/string-private.h"
62#include "MagickCore/token.h"
63#include "MagickCore/timer-private.h"
64#include "MagickCore/utility.h"
65#include "MagickCore/utility-private.h"
66#include "MagickCore/xml-tree.h"
67#include "MagickCore/xml-tree-private.h"
68#if defined(MAGICKCORE_XML_DELEGATE)
69# include <libxml/parser.h>
70# include <libxml/tree.h>
71#endif
72␌
73/*
74 Define declarations.
75*/
76#define PolicyFilename "policy.xml"
77␌
78/*
79 Typedef declarations.
80*/
81struct _PolicyInfo
82{
83 char
84 *path;
85
86 PolicyDomain
87 domain;
88
89 PolicyRights
90 rights;
91
92 char
93 *name,
94 *pattern,
95 *value;
96
97 MagickBooleanType
98 exempt,
99 stealth,
100 debug;
101
102 SemaphoreInfo
103 *semaphore;
104
105 size_t
106 signature;
107};
108
109typedef struct _PolicyMapInfo
110{
111 const PolicyDomain
112 domain;
113
114 const PolicyRights
115 rights;
116
117 const char
118 *name,
119 *pattern,
120 *value;
121} PolicyMapInfo;
122␌
123/*
124 Static declarations.
125*/
126static const PolicyMapInfo
127 PolicyMap[] =
128 {
129 { UndefinedPolicyDomain, UndefinedPolicyRights, (const char *) NULL,
130 (const char *) NULL, (const char *) NULL }
131 };
132
133static LinkedListInfo
134 *policy_cache = (LinkedListInfo *) NULL;
135
136static SemaphoreInfo
137 *policy_semaphore = (SemaphoreInfo *) NULL;
138␌
139/*
140 Forward declarations.
141*/
142static MagickBooleanType
143 IsPolicyCacheInstantiated(ExceptionInfo *),
144 LoadPolicyCache(LinkedListInfo *,const char *,const char *,const size_t,
145 ExceptionInfo *);
146␌
147/*
148%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
149% %
150% %
151% %
152% A c q u i r e P o l i c y C a c h e %
153% %
154% %
155% %
156%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
157%
158% AcquirePolicyCache() caches one or more policy configurations which provides
159% a mapping between policy attributes and a policy name.
160%
161% The format of the AcquirePolicyCache method is:
162%
163% LinkedListInfo *AcquirePolicyCache(const char *filename,
164% ExceptionInfo *exception)
165%
166% A description of each parameter follows:
167%
168% o filename: the policy configuration file name.
169%
170% o exception: return any errors or warnings in this structure.
171%
172*/
173static LinkedListInfo *AcquirePolicyCache(const char *filename,
174 ExceptionInfo *exception)
175{
176 LinkedListInfo
177 *cache;
178
179 MagickBooleanType
180 status;
181
182 ssize_t
183 i;
184
185 /*
186 Load external policy map.
187 */
188 cache=NewLinkedList(0);
189 status=MagickTrue;
190#if MAGICKCORE_ZERO_CONFIGURATION_SUPPORT
191 magick_unreferenced(filename);
192 status=LoadPolicyCache(cache,ZeroConfigurationPolicy,"[zero-configuration]",0,
193 exception);
194 if (status == MagickFalse)
195 CatchException(exception);
196#else
197 {
198 const StringInfo
199 *option;
200
201 LinkedListInfo
202 *options;
203
204 options=GetConfigureOptions(filename,exception);
205 option=(const StringInfo *) GetNextValueInLinkedList(options);
206 while (option != (const StringInfo *) NULL)
207 {
208 status=LoadPolicyCache(cache,(const char *) GetStringInfoDatum(option),
209 GetStringInfoPath(option),0,exception);
210 if (status == MagickFalse)
211 CatchException(exception);
212 option=(const StringInfo *) GetNextValueInLinkedList(options);
213 }
214 options=DestroyConfigureOptions(options);
215 }
216#endif
217 /*
218 Load built-in policy map.
219 */
220 for (i=0; i < (ssize_t) (sizeof(PolicyMap)/sizeof(*PolicyMap)); i++)
221 {
222 const PolicyMapInfo
223 *p;
224
225 PolicyInfo
226 *policy_info;
227
228 p=PolicyMap+i;
229 policy_info=(PolicyInfo *) AcquireMagickMemory(sizeof(*policy_info));
230 if (policy_info == (PolicyInfo *) NULL)
231 {
232 (void) ThrowMagickException(exception,GetMagickModule(),
233 ResourceLimitError,"MemoryAllocationFailed","`%s'",
234 p->name == (char *) NULL ? "" : p->name);
235 CatchException(exception);
236 continue;
237 }
238 (void) memset(policy_info,0,sizeof(*policy_info));
239 policy_info->path=(char *) "[built-in]";
240 policy_info->domain=p->domain;
241 policy_info->rights=p->rights;
242 policy_info->name=(char *) p->name;
243 policy_info->pattern=(char *) p->pattern;
244 policy_info->value=(char *) p->value;
245 policy_info->exempt=MagickTrue;
246 policy_info->signature=MagickCoreSignature;
247 status=AppendValueToLinkedList(cache,policy_info);
248 if (status == MagickFalse)
249 {
250 (void) ThrowMagickException(exception,GetMagickModule(),
251 ResourceLimitError,"MemoryAllocationFailed","`%s'",
252 p->name == (char *) NULL ? "" : p->name);
253 CatchException(exception);
254 }
255 }
256 return(cache);
257}
258␌
259/*
260%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
261% %
262% %
263% %
264+ G e t P o l i c y I n f o %
265% %
266% %
267% %
268%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
269%
270% GetPolicyInfo() searches the policy list for the specified name and if found
271% returns attributes for that policy.
272%
273% The format of the GetPolicyInfo method is:
274%
275% PolicyInfo *GetPolicyInfo(const char *name,ExceptionInfo *exception)
276%
277% A description of each parameter follows:
278%
279% o name: the policy name.
280%
281% o exception: return any errors or warnings in this structure.
282%
283*/
284static PolicyInfo *GetPolicyInfo(const char *name,ExceptionInfo *exception)
285{
286 char
287 policyname[MagickPathExtent],
288 *q;
289
290 ElementInfo
291 *p;
292
293 PolicyDomain
294 domain;
295
296 PolicyInfo
297 *policy;
298
299 assert(exception != (ExceptionInfo *) NULL);
300 if (IsPolicyCacheInstantiated(exception) == MagickFalse)
301 return((PolicyInfo *) NULL);
302 /*
303 Strip names of whitespace.
304 */
305 *policyname='\0';
306 if (name != (const char *) NULL)
307 (void) CopyMagickString(policyname,name,MagickPathExtent);
308 for (q=policyname; *q != '\0'; q++)
309 {
310 if (isspace((int) ((unsigned char) *q)) == 0)
311 continue;
312 (void) CopyMagickString(q,q+1,MagickPathExtent);
313 q--;
314 }
315 /*
316 Strip domain from policy name (e.g. resource:map).
317 */
318 domain=UndefinedPolicyDomain;
319 for (q=policyname; *q != '\0'; q++)
320 {
321 if (*q != ':')
322 continue;
323 *q='\0';
324 domain=(PolicyDomain) ParseCommandOption(MagickPolicyDomainOptions,
325 MagickTrue,policyname);
326 (void) CopyMagickString(policyname,q+1,MagickPathExtent);
327 break;
328 }
329 /*
330 Search for policy tag.
331 */
332 policy=(PolicyInfo *) NULL;
333 LockSemaphoreInfo(policy_semaphore);
334 ResetLinkedListIterator(policy_cache);
335 p=GetHeadElementInLinkedList(policy_cache);
336 if ((name == (const char *) NULL) || (LocaleCompare(name,"*") == 0))
337 {
338 UnlockSemaphoreInfo(policy_semaphore);
339 if (p != (ElementInfo *) NULL)
340 policy=(PolicyInfo *) p->value;
341 return(policy);
342 }
343 while (p != (ElementInfo *) NULL)
344 {
345 policy=(PolicyInfo *) p->value;
346 if ((domain == UndefinedPolicyDomain) || (policy->domain == domain))
347 if (LocaleCompare(policyname,policy->name) == 0)
348 break;
349 p=p->next;
350 }
351 if (p == (ElementInfo *) NULL)
352 policy=(PolicyInfo *) NULL;
353 else
354 (void) SetHeadElementInLinkedList(policy_cache,p);
355 UnlockSemaphoreInfo(policy_semaphore);
356 return(policy);
357}
358␌
359/*
360%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
361% %
362% %
363% %
364% G e t P o l i c y I n f o L i s t %
365% %
366% %
367% %
368%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
369%
370% GetPolicyInfoList() returns any policies that match the specified pattern.
371%
372% The format of the GetPolicyInfoList function is:
373%
374% const PolicyInfo **GetPolicyInfoList(const char *pattern,
375% size_t *number_policies,ExceptionInfo *exception)
376%
377% A description of each parameter follows:
378%
379% o pattern: Specifies a pointer to a text string containing a pattern.
380%
381% o number_policies: returns the number of policies in the list.
382%
383% o exception: return any errors or warnings in this structure.
384%
385*/
386MagickExport const PolicyInfo **GetPolicyInfoList(const char *pattern,
387 size_t *number_policies,ExceptionInfo *exception)
388{
389 const PolicyInfo
390 **policies;
391
392 ElementInfo
393 *p;
394
395 ssize_t
396 i;
397
398 assert(pattern != (char *) NULL);
399 assert(number_policies != (size_t *) NULL);
400 if (IsEventLogging() != MagickFalse)
401 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",pattern);
402 *number_policies=0;
403 if (IsPolicyCacheInstantiated(exception) == MagickFalse)
404 return((const PolicyInfo **) NULL);
405 policies=(const PolicyInfo **) AcquireQuantumMemory((size_t)
406 GetNumberOfElementsInLinkedList(policy_cache)+1UL,sizeof(*policies));
407 if (policies == (const PolicyInfo **) NULL)
408 return((const PolicyInfo **) NULL);
409 LockSemaphoreInfo(policy_semaphore);
410 p=GetHeadElementInLinkedList(policy_cache);
411 for (i=0; p != (ElementInfo *) NULL; )
412 {
413 const PolicyInfo
414 *policy;
415
416 policy=(const PolicyInfo *)p->value;
417 if ((policy->stealth == MagickFalse) &&
418 (GlobExpression(policy->name,pattern,MagickFalse) != MagickFalse))
419 policies[i++]=policy;
420 p=p->next;
421 }
422 UnlockSemaphoreInfo(policy_semaphore);
423 if (i == 0)
424 policies=(const PolicyInfo **) RelinquishMagickMemory((void*) policies);
425 else
426 policies[i]=(PolicyInfo *) NULL;
427 *number_policies=(size_t) i;
428 return(policies);
429}
430␌
431/*
432%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
433% %
434% %
435% %
436% G e t P o l i c y L i s t %
437% %
438% %
439% %
440%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
441%
442% GetPolicyList() returns any policies that match the specified pattern.
443%
444% The format of the GetPolicyList function is:
445%
446% char **GetPolicyList(const char *pattern,size_t *number_policies,
447% ExceptionInfo *exception)
448%
449% A description of each parameter follows:
450%
451% o pattern: a pointer to a text string containing a pattern.
452%
453% o number_policies: returns the number of policies in the list.
454%
455% o exception: return any errors or warnings in this structure.
456%
457*/
458
459static char *AcquirePolicyString(const char *source,const size_t pad)
460{
461 char
462 *destination;
463
464 size_t
465 length;
466
467 length=0;
468 if (source != (char *) NULL)
469 length+=strlen(source);
470 destination=(char *) NULL;
471 /* AcquireMagickMemory needs to be used here to avoid an omp deadlock */
472 if (~length >= pad)
473 destination=(char *) AcquireMagickMemory((length+pad)*sizeof(*destination));
474 if (destination == (char *) NULL)
475 ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
476 if (source != (char *) NULL)
477 (void) memcpy(destination,source,length*sizeof(*destination));
478 destination[length]='\0';
479 return(destination);
480}
481
482MagickExport char **GetPolicyList(const char *pattern,size_t *number_policies,
483 ExceptionInfo *exception)
484{
485 char
486 **policies;
487
488 const ElementInfo
489 *p;
490
491 ssize_t
492 i;
493
494 assert(pattern != (char *) NULL);
495 assert(number_policies != (size_t *) NULL);
496 if (IsEventLogging() != MagickFalse)
497 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",pattern);
498 *number_policies=0;
499 if (IsPolicyCacheInstantiated(exception) == MagickFalse)
500 return((char **) NULL);
501 policies=(char **) AcquireQuantumMemory((size_t)
502 GetNumberOfElementsInLinkedList(policy_cache)+1UL,sizeof(*policies));
503 if (policies == (char **) NULL)
504 return((char **) NULL);
505 LockSemaphoreInfo(policy_semaphore);
506 p=GetHeadElementInLinkedList(policy_cache);
507 for (i=0; p != (ElementInfo *) NULL; )
508 {
509 const PolicyInfo
510 *policy;
511
512 policy=(const PolicyInfo *) p->value;
513 if ((policy->stealth == MagickFalse) &&
514 (GlobExpression(policy->name,pattern,MagickFalse) != MagickFalse))
515 policies[i++]=AcquirePolicyString(policy->name,1);
516 p=p->next;
517 }
518 UnlockSemaphoreInfo(policy_semaphore);
519 if (i == 0)
520 policies=(char **) RelinquishMagickMemory(policies);
521 else
522 policies[i]=(char *) NULL;
523 *number_policies=(size_t) i;
524 return(policies);
525}
526␌
527/*
528%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
529% %
530% %
531% %
532% G e t P o l i c y V a l u e %
533% %
534% %
535% %
536%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
537%
538% GetPolicyValue() returns the value associated with the named policy.
539%
540% The format of the GetPolicyValue method is:
541%
542% char *GetPolicyValue(const char *name)
543%
544% A description of each parameter follows:
545%
546% o name: The name of the policy.
547%
548*/
549MagickExport char *GetPolicyValue(const char *name)
550{
551 const char
552 *value;
553
554 const PolicyInfo
555 *policy_info;
556
557 ExceptionInfo
558 *exception;
559
560 assert(name != (const char *) NULL);
561 if (IsEventLogging() != MagickFalse)
562 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",name);
563 exception=AcquireExceptionInfo();
564 policy_info=GetPolicyInfo(name,exception);
565 exception=DestroyExceptionInfo(exception);
566 if (policy_info == (PolicyInfo *) NULL)
567 return((char *) NULL);
568 value=policy_info->value;
569 if ((value == (const char *) NULL) || (*value == '\0'))
570 return((char *) NULL);
571 return(AcquirePolicyString(value,1));
572}
573␌
574/*
575%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
576% %
577% %
578% %
579+ I s P o l i c y C a c h e I n s t a n t i a t e d %
580% %
581% %
582% %
583%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
584%
585% IsPolicyCacheInstantiated() determines if the policy list is instantiated.
586% If not, it instantiates the list and returns it.
587%
588% The format of the IsPolicyInstantiated method is:
589%
590% MagickBooleanType IsPolicyCacheInstantiated(ExceptionInfo *exception)
591%
592% A description of each parameter follows.
593%
594% o exception: return any errors or warnings in this structure.
595%
596*/
597static MagickBooleanType IsPolicyCacheInstantiated(ExceptionInfo *exception)
598{
599 if (policy_cache == (LinkedListInfo *) NULL)
600 {
601 GetMaxMemoryRequest(); /* avoid OMP deadlock */
602 if (policy_semaphore == (SemaphoreInfo *) NULL)
603 ActivateSemaphoreInfo(&policy_semaphore);
604 LockSemaphoreInfo(policy_semaphore);
605 if (policy_cache == (LinkedListInfo *) NULL)
606 policy_cache=AcquirePolicyCache(PolicyFilename,exception);
607 UnlockSemaphoreInfo(policy_semaphore);
608 }
609 return(policy_cache != (LinkedListInfo *) NULL ? MagickTrue : MagickFalse);
610}
611␌
612/*
613%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
614% %
615% %
616% %
617% I s R i g h t s A u t h o r i z e d %
618% %
619% %
620% %
621%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
622%
623% IsRightsAuthorized() returns MagickTrue if the policy authorizes the
624% requested rights for the specified domain.
625%
626% The format of the IsRightsAuthorized method is:
627%
628% MagickBooleanType IsRightsAuthorized(const PolicyDomain domain,
629% const PolicyRights rights,const char *pattern)
630%
631% A description of each parameter follows:
632%
633% o domain: the policy domain.
634%
635% o rights: the policy rights.
636%
637% o pattern: the coder, delegate, filter, or path pattern.
638%
639*/
640MagickExport MagickBooleanType IsRightsAuthorized(const PolicyDomain domain,
641 const PolicyRights rights,const char *pattern)
642{
643 char
644 *real_pattern = (char *) NULL;
645
646 const PolicyInfo
647 *policy_info;
648
649 ExceptionInfo
650 *exception;
651
652 MagickBooleanType
653 authorized,
654 match;
655
656 ElementInfo
657 *p;
658
659 if ((GetLogEventMask() & PolicyEvent) != 0)
660 (void) LogMagickEvent(PolicyEvent,GetMagickModule(),
661 "Domain: %s; rights=%s; pattern=\"%s\" ...",
662 CommandOptionToMnemonic(MagickPolicyDomainOptions,domain),
663 CommandOptionToMnemonic(MagickPolicyRightsOptions,rights),pattern);
664 exception=AcquireExceptionInfo();
665 policy_info=GetPolicyInfo("*",exception);
666 exception=DestroyExceptionInfo(exception);
667 if (policy_info == (PolicyInfo *) NULL)
668 return(MagickTrue);
669 authorized=MagickTrue;
670 LockSemaphoreInfo(policy_semaphore);
671 p=GetHeadElementInLinkedList(policy_cache);
672 while (p != (ElementInfo *) NULL)
673 {
674 const PolicyInfo
675 *policy;
676
677 policy=(const PolicyInfo *) p->value;
678 if (policy->domain == domain)
679 {
680 if ((policy->domain == PathPolicyDomain) &&
681 (real_pattern == (const char *) NULL))
682 real_pattern=realpath_utf8(pattern);
683 if (real_pattern != (char*) NULL)
684 match=GlobExpression(real_pattern,policy->pattern,MagickFalse);
685 else
686 match=GlobExpression(pattern,policy->pattern,MagickFalse);
687 if (match != MagickFalse)
688 {
689 if ((rights & ReadPolicyRights) != 0)
690 authorized=(policy->rights & ReadPolicyRights) != 0 ? MagickTrue :
691 MagickFalse;
692 if ((rights & WritePolicyRights) != 0)
693 authorized=(policy->rights & WritePolicyRights) != 0 ?
694 MagickTrue : MagickFalse;
695 if ((rights & ExecutePolicyRights) != 0)
696 authorized=(policy->rights & ExecutePolicyRights) != 0 ?
697 MagickTrue : MagickFalse;
698 }
699 }
700 p=p->next;
701 }
702 UnlockSemaphoreInfo(policy_semaphore);
703 if (real_pattern != (char *) NULL)
704 real_pattern=DestroyString(real_pattern);
705 return(authorized);
706}
707␌
708/*
709%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
710% %
711% %
712% %
713% L i s t P o l i c y I n f o %
714% %
715% %
716% %
717%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
718%
719% ListPolicyInfo() lists policies to the specified file.
720%
721% The format of the ListPolicyInfo method is:
722%
723% MagickBooleanType ListPolicyInfo(FILE *file,ExceptionInfo *exception)
724%
725% A description of each parameter follows.
726%
727% o file: List policy names to this file handle.
728%
729% o exception: return any errors or warnings in this structure.
730%
731*/
732MagickExport MagickBooleanType ListPolicyInfo(FILE *file,
733 ExceptionInfo *exception)
734{
735 const char
736 *path,
737 *domain;
738
739 const PolicyInfo
740 **policy_info;
741
742 ssize_t
743 i;
744
745 size_t
746 number_policies;
747
748 /*
749 List name and attributes of each policy in the list.
750 */
751 if (file == (const FILE *) NULL)
752 file=stdout;
753 policy_info=GetPolicyInfoList("*",&number_policies,exception);
754 if (policy_info == (const PolicyInfo **) NULL)
755 return(MagickFalse);
756 path=(const char *) NULL;
757 for (i=0; i < (ssize_t) number_policies; i++)
758 {
759 if (policy_info[i]->stealth != MagickFalse)
760 continue;
761 if (((path == (const char *) NULL) ||
762 (LocaleCompare(path,policy_info[i]->path) != 0)) &&
763 (policy_info[i]->path != (char *) NULL))
764 (void) FormatLocaleFile(file,"\nPath: %s\n",policy_info[i]->path);
765 path=policy_info[i]->path;
766 domain=CommandOptionToMnemonic(MagickPolicyDomainOptions,
767 policy_info[i]->domain);
768 (void) FormatLocaleFile(file," Policy: %s\n",domain);
769 if ((policy_info[i]->domain == CachePolicyDomain) ||
770 (policy_info[i]->domain == ResourcePolicyDomain) ||
771 (policy_info[i]->domain == SystemPolicyDomain))
772 {
773 if (policy_info[i]->name != (char *) NULL)
774 (void) FormatLocaleFile(file," name: %s\n",policy_info[i]->name);
775 if (policy_info[i]->value != (char *) NULL)
776 (void) FormatLocaleFile(file," value: %s\n",policy_info[i]->value);
777 }
778 else
779 {
780 (void) FormatLocaleFile(file," rights: ");
781 if (policy_info[i]->rights == NoPolicyRights)
782 (void) FormatLocaleFile(file,"None ");
783 if ((policy_info[i]->rights & ReadPolicyRights) != 0)
784 (void) FormatLocaleFile(file,"Read ");
785 if ((policy_info[i]->rights & WritePolicyRights) != 0)
786 (void) FormatLocaleFile(file,"Write ");
787 if ((policy_info[i]->rights & ExecutePolicyRights) != 0)
788 (void) FormatLocaleFile(file,"Execute ");
789 (void) FormatLocaleFile(file,"\n");
790 if (policy_info[i]->pattern != (char *) NULL)
791 (void) FormatLocaleFile(file," pattern: %s\n",
792 policy_info[i]->pattern);
793 }
794 }
795 policy_info=(const PolicyInfo **) RelinquishMagickMemory((void *)
796 policy_info);
797 (void) fflush(file);
798 return(MagickTrue);
799}
800␌
801/*
802%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
803% %
804% %
805% %
806+ L o a d P o l i c y C a c h e %
807% %
808% %
809% %
810%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
811%
812% LoadPolicyCache() loads the policy configurations which provides a mapping
813% between policy attributes and a policy domain.
814%
815% The format of the LoadPolicyCache method is:
816%
817% MagickBooleanType LoadPolicyCache(LinkedListInfo *cache,const char *xml,
818% const char *filename,const size_t depth,ExceptionInfo *exception)
819%
820% A description of each parameter follows:
821%
822% o xml: The policy list in XML format.
823%
824% o filename: The policy list filename.
825%
826% o depth: depth of <include /> statements.
827%
828% o exception: return any errors or warnings in this structure.
829%
830*/
831static MagickBooleanType LoadPolicyCache(LinkedListInfo *cache,
832 const char *policy,const char *filename,const size_t depth,
833 ExceptionInfo *exception)
834{
835 char
836 keyword[MagickPathExtent],
837 *token;
838
839 const char
840 *q;
841
842 MagickStatusType
843 status;
844
845 PolicyInfo
846 *policy_info;
847
848 size_t
849 extent;
850
851 /*
852 Load the policy map file.
853 */
854 (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),
855 "Loading policy file \"%s\" ...",filename);
856 if (policy == (char *) NULL)
857 return(MagickFalse);
858 status=MagickTrue;
859 policy_info=(PolicyInfo *) NULL;
860 token=AcquirePolicyString(policy,MagickPathExtent);
861 extent=strlen(token)+MagickPathExtent;
862 for (q=policy; *q != '\0'; )
863 {
864 /*
865 Interpret XML.
866 */
867 (void) GetNextToken(q,&q,extent,token);
868 if (*token == '\0')
869 break;
870 (void) CopyMagickString(keyword,token,MagickPathExtent);
871 if (LocaleNCompare(keyword,"<!DOCTYPE",9) == 0)
872 {
873 /*
874 Docdomain element.
875 */
876 while ((LocaleNCompare(q,"]>",2) != 0) && (*q != '\0'))
877 (void) GetNextToken(q,&q,extent,token);
878 continue;
879 }
880 if (LocaleNCompare(keyword,"<!--",4) == 0)
881 {
882 /*
883 Comment element.
884 */
885 while ((LocaleNCompare(q,"->",2) != 0) && (*q != '\0'))
886 (void) GetNextToken(q,&q,extent,token);
887 continue;
888 }
889 if (LocaleCompare(keyword,"<include") == 0)
890 {
891 /*
892 Include element.
893 */
894 while (((*token != '/') && (*(token+1) != '>')) && (*q != '\0'))
895 {
896 (void) CopyMagickString(keyword,token,MagickPathExtent);
897 (void) GetNextToken(q,&q,extent,token);
898 if (*token != '=')
899 continue;
900 (void) GetNextToken(q,&q,extent,token);
901 if (LocaleCompare(keyword,"file") == 0)
902 {
903 if (depth > MagickMaxRecursionDepth)
904 (void) ThrowMagickException(exception,GetMagickModule(),
905 ConfigureError,"IncludeElementNestedTooDeeply","`%s'",token);
906 else
907 {
908 char
909 path[MagickPathExtent],
910 *file_xml;
911
912 GetPathComponent(filename,HeadPath,path);
913 if (*path != '\0')
914 (void) ConcatenateMagickString(path,DirectorySeparator,
915 MagickPathExtent);
916 if (*token == *DirectorySeparator)
917 (void) CopyMagickString(path,token,MagickPathExtent);
918 else
919 (void) ConcatenateMagickString(path,token,MagickPathExtent);
920 file_xml=FileToXML(path,~0UL);
921 if (file_xml != (char *) NULL)
922 {
923 status&=(MagickStatusType) LoadPolicyCache(cache,file_xml,
924 path,depth+1,exception);
925 file_xml=DestroyString(file_xml);
926 }
927 }
928 }
929 }
930 continue;
931 }
932 if (LocaleCompare(keyword,"<policy") == 0)
933 {
934 /*
935 Policy element.
936 */
937 policy_info=(PolicyInfo *) AcquireCriticalMemory(sizeof(*policy_info));
938 (void) memset(policy_info,0,sizeof(*policy_info));
939 policy_info->path=AcquirePolicyString(filename,1);
940 policy_info->exempt=MagickFalse;
941 policy_info->signature=MagickCoreSignature;
942 continue;
943 }
944 if (policy_info == (PolicyInfo *) NULL)
945 continue;
946 if ((LocaleCompare(keyword,"/>") == 0) ||
947 (LocaleCompare(keyword,"</policy>") == 0))
948 {
949 status=AppendValueToLinkedList(cache,policy_info);
950 if (status == MagickFalse)
951 (void) ThrowMagickException(exception,GetMagickModule(),
952 ResourceLimitError,"MemoryAllocationFailed","`%s'",
953 policy_info->name);
954 policy_info=(PolicyInfo *) NULL;
955 continue;
956 }
957 (void) GetNextToken(q,(const char **) NULL,extent,token);
958 if (*token != '=')
959 continue;
960 (void) GetNextToken(q,&q,extent,token);
961 (void) GetNextToken(q,&q,extent,token);
962 switch (*keyword)
963 {
964 case 'D':
965 case 'd':
966 {
967 if (LocaleCompare((char *) keyword,"domain") == 0)
968 {
969 policy_info->domain=(PolicyDomain) ParseCommandOption(
970 MagickPolicyDomainOptions,MagickTrue,token);
971 break;
972 }
973 break;
974 }
975 case 'N':
976 case 'n':
977 {
978 if (LocaleCompare((char *) keyword,"name") == 0)
979 {
980 policy_info->name=AcquirePolicyString(token,1);
981 break;
982 }
983 break;
984 }
985 case 'P':
986 case 'p':
987 {
988 if (LocaleCompare((char *) keyword,"pattern") == 0)
989 {
990 policy_info->pattern=AcquirePolicyString(token,1);
991 break;
992 }
993 break;
994 }
995 case 'R':
996 case 'r':
997 {
998 if (LocaleCompare((char *) keyword,"rights") == 0)
999 {
1000 policy_info->rights=(PolicyRights) ParseCommandOption(
1001 MagickPolicyRightsOptions,MagickTrue,token);
1002 break;
1003 }
1004 break;
1005 }
1006 case 'S':
1007 case 's':
1008 {
1009 if (LocaleCompare((char *) keyword,"stealth") == 0)
1010 {
1011 policy_info->stealth=IsStringTrue(token);
1012 break;
1013 }
1014 break;
1015 }
1016 case 'V':
1017 case 'v':
1018 {
1019 if (LocaleCompare((char *) keyword,"value") == 0)
1020 {
1021 policy_info->value=AcquirePolicyString(token,1);
1022 break;
1023 }
1024 break;
1025 }
1026 default:
1027 break;
1028 }
1029 }
1030 token=(char *) RelinquishMagickMemory(token);
1031 return(status != 0 ? MagickTrue : MagickFalse);
1032}
1033␌
1034/*
1035%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1036% %
1037% %
1038% %
1039+ P o l i c y C o m p o n e n t G e n e s i s %
1040% %
1041% %
1042% %
1043%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1044%
1045% PolicyComponentGenesis() instantiates the policy component.
1046%
1047% The format of the PolicyComponentGenesis method is:
1048%
1049% MagickBooleanType PolicyComponentGenesis(void)
1050%
1051*/
1052MagickPrivate MagickBooleanType PolicyComponentGenesis(void)
1053{
1054 if (policy_semaphore == (SemaphoreInfo *) NULL)
1055 policy_semaphore=AcquireSemaphoreInfo();
1056 return(MagickTrue);
1057}
1058␌
1059/*
1060%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1061% %
1062% %
1063% %
1064+ P o l i c y C o m p o n e n t T e r m i n u s %
1065% %
1066% %
1067% %
1068%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1069%
1070% PolicyComponentTerminus() destroys the policy component.
1071%
1072% The format of the PolicyComponentTerminus method is:
1073%
1074% PolicyComponentTerminus(void)
1075%
1076*/
1077
1078static void *DestroyPolicyElement(void *policy_info)
1079{
1080 PolicyInfo
1081 *p;
1082
1083 p=(PolicyInfo *) policy_info;
1084 if (p->exempt == MagickFalse)
1085 {
1086 if (p->value != (char *) NULL)
1087 p->value=DestroyString(p->value);
1088 if (p->pattern != (char *) NULL)
1089 p->pattern=DestroyString(p->pattern);
1090 if (p->name != (char *) NULL)
1091 p->name=DestroyString(p->name);
1092 if (p->path != (char *) NULL)
1093 p->path=DestroyString(p->path);
1094 }
1095 p=(PolicyInfo *) RelinquishMagickMemory(p);
1096 return((void *) NULL);
1097}
1098
1099MagickPrivate void PolicyComponentTerminus(void)
1100{
1101 if (policy_semaphore == (SemaphoreInfo *) NULL)
1102 ActivateSemaphoreInfo(&policy_semaphore);
1103 LockSemaphoreInfo(policy_semaphore);
1104 if (policy_cache != (LinkedListInfo *) NULL)
1105 policy_cache=DestroyLinkedList(policy_cache,DestroyPolicyElement);
1106 UnlockSemaphoreInfo(policy_semaphore);
1107 RelinquishSemaphoreInfo(&policy_semaphore);
1108}
1109␌
1110/*
1111%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1112% %
1113% %
1114% %
1115% S e t M a g i c k S e c u r i t y P o l i c y %
1116% %
1117% %
1118% %
1119%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1120%
1121% SetMagickSecurityPolicy() sets or restricts the ImageMagick security policy.
1122% It returns MagickFalse if the policy the policy does not parse.
1123%
1124% The format of the SetMagickSecurityPolicy method is:
1125%
1126% MagickBooleanType SetMagickSecurityPolicy(const char *policy,
1127% ExceptionInfo *exception)
1128%
1129% A description of each parameter follows:
1130%
1131% o policy: the security policy in the XML format.
1132%
1133% o exception: return any errors or warnings in this structure.
1134%
1135*/
1136
1137static MagickBooleanType ValidateSecurityPolicy(const char *policy,
1138 const char *url,ExceptionInfo *exception)
1139{
1140#if defined(MAGICKCORE_XML_DELEGATE)
1141 xmlDocPtr
1142 document;
1143
1144 /*
1145 Parse security policy.
1146 */
1147 document=xmlReadMemory(policy,(int) strlen(policy),url,NULL,
1148 XML_PARSE_NOERROR | XML_PARSE_NOWARNING);
1149 if (document == (xmlDocPtr) NULL)
1150 {
1151 (void) ThrowMagickException(exception,GetMagickModule(),ConfigureError,
1152 "PolicyValidationException","'%s'",url);
1153 return(MagickFalse);
1154 }
1155 xmlFreeDoc(document);
1156#else
1157 (void) policy;
1158 (void) url;
1159 (void) exception;
1160#endif
1161 return(MagickTrue);
1162}
1163
1164MagickExport MagickBooleanType SetMagickSecurityPolicy(const char *policy,
1165 ExceptionInfo *exception)
1166{
1167 MagickBooleanType
1168 status;
1169
1170 LinkedListInfo
1171 *user_policies;
1172
1173 PolicyInfo
1174 *p;
1175
1176 /*
1177 Load user policies.
1178 */
1179 assert(exception != (ExceptionInfo *) NULL);
1180 if (policy == (const char *) NULL)
1181 return(MagickFalse);
1182 if (ValidateSecurityPolicy(policy,PolicyFilename,exception) == MagickFalse)
1183 return(MagickFalse);
1184 status=LoadPolicyCache(policy_cache,policy,"[user-policy]",0,exception);
1185 if (status == MagickFalse)
1186 return(status);
1187 /*
1188 Synchronize user policies.
1189 */
1190 user_policies=NewLinkedList(0);
1191 status=LoadPolicyCache(user_policies,policy,"[user-policy]",0,exception);
1192 if (status == MagickFalse)
1193 {
1194 user_policies=DestroyLinkedList(user_policies,DestroyPolicyElement);
1195 return(MagickFalse);
1196 }
1197 ResetLinkedListIterator(user_policies);
1198 p=(PolicyInfo *) GetNextValueInLinkedList(user_policies);
1199 while (p != (PolicyInfo *) NULL)
1200 {
1201 if ((p->name != (char *) NULL) && (p->value != (char *) NULL))
1202 (void) SetMagickSecurityPolicyValue(p->domain,p->name,p->value,exception);
1203 p=(PolicyInfo *) GetNextValueInLinkedList(user_policies);
1204 }
1205 user_policies=DestroyLinkedList(user_policies,DestroyPolicyElement);
1206 return(status);
1207}
1208␌
1209/*
1210%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1211% %
1212% %
1213% %
1214% S e t M a g i c k S e c u r i t y P o l i c y V a l u e %
1215% %
1216% %
1217% %
1218%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1219%
1220% SetMagickSecurityPolicyValue() sets a value associated with an ImageMagick
1221% security policy. For most policies, the value must be less than any value
1222% set by the security policy configuration file (i.e. policy.xml). It returns
1223% MagickFalse if the policy cannot be modified or if the policy does not parse.
1224%
1225% The format of the SetMagickSecurityPolicyValue method is:
1226%
1227% MagickBooleanType SetMagickSecurityPolicyValue(
1228% const PolicyDomain domain,const char *name,const char *value,
1229% ExceptionInfo *exception)
1230%
1231% A description of each parameter follows:
1232%
1233% o domain: the domain of the policy (e.g. system, resource).
1234%
1235% o name: the name of the policy.
1236%
1237% o value: the value to set the policy to.
1238%
1239% o exception: return any errors or warnings in this structure.
1240%
1241*/
1242MagickExport MagickBooleanType SetMagickSecurityPolicyValue(
1243 const PolicyDomain domain,const char *name,const char *value,
1244 ExceptionInfo *exception)
1245{
1246 magick_unreferenced(exception);
1247 assert(exception != (ExceptionInfo *) NULL);
1248 if ((name == (const char *) NULL) || (value == (const char *) NULL))
1249 return(MagickFalse);
1250 switch (domain)
1251 {
1252 case CachePolicyDomain:
1253 {
1254 if (LocaleCompare(name,"memory-map") == 0)
1255 {
1256 if (LocaleCompare(value,"anonymous") != 0)
1257 return(MagickFalse);
1258 ResetCacheAnonymousMemory();
1259 ResetStreamAnonymousMemory();
1260 return(MagickTrue);
1261 }
1262 break;
1263 }
1264 case ResourcePolicyDomain:
1265 {
1266 ssize_t
1267 type;
1268
1269 type=ParseCommandOption(MagickResourceOptions,MagickFalse,name);
1270 if (type >= 0)
1271 {
1272 MagickSizeType
1273 limit;
1274
1275 limit=MagickResourceInfinity;
1276 if (LocaleCompare("unlimited",value) != 0)
1277 limit=StringToMagickSizeType(value,100.0);
1278 if ((ResourceType) type == TimeResource)
1279 limit=(MagickSizeType) ParseMagickTimeToLive(value);
1280 return(SetMagickResourceLimit((ResourceType) type,limit));
1281 }
1282 break;
1283 }
1284 case SystemPolicyDomain:
1285 {
1286 if (LocaleCompare(name,"max-memory-request") == 0)
1287 {
1288 MagickSizeType
1289 limit;
1290
1291 limit=MagickResourceInfinity;
1292 if (LocaleCompare("unlimited",value) != 0)
1293 limit=StringToMagickSizeType(value,100.0);
1294 SetMaxMemoryRequest(limit);
1295 return(MagickTrue);
1296 }
1297 if (LocaleCompare(name,"max-profile-size") == 0)
1298 {
1299 MagickSizeType
1300 limit;
1301
1302 limit=MagickResourceInfinity;
1303 if (LocaleCompare("unlimited",value) != 0)
1304 limit=StringToMagickSizeType(value,100.0);
1305 SetMaxProfileSize(limit);
1306 return(MagickTrue);
1307 }
1308 if (LocaleCompare(name,"memory-map") == 0)
1309 {
1310 if (LocaleCompare(value,"anonymous") != 0)
1311 return(MagickFalse);
1312 ResetVirtualAnonymousMemory();
1313 return(MagickTrue);
1314 }
1315 if (LocaleCompare(name,"precision") == 0)
1316 {
1317 int
1318 limit;
1319
1320 limit=StringToInteger(value);
1321 SetMagickPrecision(limit);
1322 return(MagickTrue);
1323 }
1324 break;
1325 }
1326 case CoderPolicyDomain:
1327 case DelegatePolicyDomain:
1328 case FilterPolicyDomain:
1329 case ModulePolicyDomain:
1330 case PathPolicyDomain:
1331 default:
1332 break;
1333 }
1334 return(MagickFalse);
1335}
_PolicyInfo
Definition policy.c:82
_PolicyMapInfo
Definition policy.c:110